Attachment #308579 for bug #494034

View | Details | Raw Unified | Return to bug 494034
Collapse All | Expand All

Lines 297-304 FILES = \ Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Makefile.am (-1 / +1 lines)
297	Mono.UIAutomation.Winforms.Events/DateTimePicker/AutomationNamePropertyEvent.cs \	297	Mono.UIAutomation.Winforms.Events/DateTimePicker/AutomationNamePropertyEvent.cs \
298	Mono.UIAutomation.Winforms.Events/DateTimePicker/ButtonInvokePatternInvokedEvent.cs \	298	Mono.UIAutomation.Winforms.Events/DateTimePicker/ButtonInvokePatternInvokedEvent.cs \
299	Mono.UIAutomation.Winforms.Events/DateTimePicker/CheckboxAutomationHasKeyboardFocusPropertyEvent.cs \	299	Mono.UIAutomation.Winforms.Events/DateTimePicker/CheckboxAutomationHasKeyboardFocusPropertyEvent.cs \
300	Mono.UIAutomation.Winforms.Events/DateTimePicker/PartAutomationIsEnabledPropertyEvent.cs \
301	Mono.UIAutomation.Winforms.Events/DateTimePicker/PartAutomationHasKeyboardFocusPropertyEvent.cs \	300	Mono.UIAutomation.Winforms.Events/DateTimePicker/PartAutomationHasKeyboardFocusPropertyEvent.cs \
		301	Mono.UIAutomation.Winforms.Events/DateTimePicker/PartAutomationIsEnabledPropertyEvent.cs \
302	Mono.UIAutomation.Winforms.Events/DateTimePicker/PartListItemAutomationHasKeyboardFocusPropertyEvent.cs \	302	Mono.UIAutomation.Winforms.Events/DateTimePicker/PartListItemAutomationHasKeyboardFocusPropertyEvent.cs \
303	Mono.UIAutomation.Winforms.Events/DateTimePicker/PartListItemSelectionItemPatternElementSelectedEvent.cs \	303	Mono.UIAutomation.Winforms.Events/DateTimePicker/PartListItemSelectionItemPatternElementSelectedEvent.cs \
304	Mono.UIAutomation.Winforms.Events/DateTimePicker/PartListItemSelectionItemPatternIsSelectedEvent.cs \	304	Mono.UIAutomation.Winforms.Events/DateTimePicker/PartListItemSelectionItemPatternIsSelectedEvent.cs \

Lines 66-76 namespace Mono.UIAutomation.Winforms.Behaviors.BalloonWindow Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/BalloonWindow/EmbeddedImageProviderBehavior.cs (-3 / +5 lines)
66	get {	66	get {
67	// from ThemeWin32Classic.cs	67	// from ThemeWin32Classic.cs
68	int borderSize = 8;	68	int borderSize = 8;
69	int iconSize = (balloonWindow.Icon == SWF.ToolTipIcon.None) ? 0 : 16;	69	int iconSize = 0;
		70	if (balloonWindow.InvokeSync (c => !(c.Icon == SWF.ToolTipIcon.None)))
		71	iconSize = 16;
70	if (iconSize == 0)	72	if (iconSize == 0)
71	return Rect.Empty;	73	return Rect.Empty;
72	int imageX, imageY, imageWidth, imageHeight;	74	int imageX, imageY, imageWidth, imageHeight;
73		75
74	Rect balloonRect	76	Rect balloonRect
75	= (Rect) Provider.GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id);	77	= (Rect) Provider.GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id);
76		78
Lines 78-84 namespace Mono.UIAutomation.Winforms.Behaviors.BalloonWindow Link Here
78	imageY = (int) balloonRect.Y + borderSize;	80	imageY = (int) balloonRect.Y + borderSize;
79	imageWidth = iconSize;	81	imageWidth = iconSize;
80	imageHeight = iconSize;	82	imageHeight = iconSize;
81		83
82	Rect imageRect = new Rect (imageX, imageY, imageWidth, imageHeight);	84	Rect imageRect = new Rect (imageX, imageY, imageWidth, imageHeight);
83	balloonRect.Intersect (imageRect);	85	balloonRect.Intersect (imageRect);
84	return balloonRect;	86	return balloonRect;




		
		public virtual void Invoke ()
		{
			if (Provider.Control.InvokeSync (e => !e.Enabled))
				throw new ElementNotEnabledException ();

			Provider.Control.InvokeSync (delegate {
			// TODO: Use internal property when backport
//				ColorDialog.BaseColorControl.SmallColorControl selected =
//					((ColorDialog.BaseColorControl) baseColorControl).UIASelectedSmallColorControl;
				try {
					ColorDialog.BaseColorControl.SmallColorControl selected =
						Helper.GetPrivateProperty<ColorDialog.BaseColorControl, ColorDialog.BaseColorControl.SmallColorControl>
							((ColorDialog.BaseColorControl) baseColorControl, "UIASelectedSmallColorControl");
					if (selected != null)
						selected.IsSelected = false;
				} catch (NotSupportedException) { }
				smallColorControl.IsSelected = true;
			});
		}
		
		#endregion	
		
		#region Private Methods
		
		private void PerformClick ()
		{
			if (Provider.Control.InvokeRequired == true) {
				Provider.Control.BeginInvoke (new MethodInvoker (PerformClick));
				return;
			}

			// TODO: Use internal property when backport
//			ColorDialog.BaseColorControl.SmallColorControl selected =
//				((ColorDialog.BaseColorControl) baseColorControl).UIASelectedSmallColorControl;
			try {
				ColorDialog.BaseColorControl.SmallColorControl selected =
					Helper.GetPrivateProperty<ColorDialog.BaseColorControl, ColorDialog.BaseColorControl.SmallColorControl>
						((ColorDialog.BaseColorControl) baseColorControl, "UIASelectedSmallColorControl");
				if (selected != null)
					selected.IsSelected = false;
			} catch (NotSupportedException) { }
			smallColorControl.IsSelected = true;
		}
		
		#endregion

		#region Private Field

		ColorDialog.BaseColorControl.SmallColorControl smallColorControl;




		
		public virtual void Invoke ()
		{
			if (button.InvokeSync (c => !c.Enabled))
				throw new ElementNotEnabledException ();

			button.InvokeSync (delegate { button.PerformClick (); });
		}
		
		#endregion	
		
		#region Private Methods
		
		private void PerformClick ()
		{
			if (Provider.Control.InvokeRequired == true) {
				Provider.Control.BeginInvoke (new SWF.MethodInvoker (PerformClick));
				return;
			}
			button.PerformClick ();
		}
		
		#endregion




	
		public void Toggle ()
		{
			if (checkbox.InvokeSync (c => !c.Enabled))
				throw new ElementNotEnabledException ();

			SWF.CheckState newState = SWF.CheckState.Checked;

			switch (checkbox.InvokeSync (c => c.CheckState)) {
			case SWF.CheckState.Checked:
				newState = SWF.CheckState.Unchecked;
				break;
			case SWF.CheckState.Unchecked:
				if (checkbox.InvokeSync (c => c.ThreeState))
					newState = SWF.CheckState.Indeterminate;
				else
					newState = SWF.CheckState.Checked;
				break;
			// Control could still have been set to intermediate
			// programatically, regardless of ThreeState value.
			case SWF.CheckState.Indeterminate:
			default:
				newState = SWF.CheckState.Checked;
				break;
			}

			checkbox.InvokeSync (delegate { PerformToggle (newState); });
		}

		public ToggleState ToggleState {

		
		#region Private Methods
		
		private void PerformToggle (SWF.CheckState state)
		{
			if (checkbox.InvokeRequired == true) {
				checkbox.BeginInvoke (new PerformToggleDelegate (PerformToggle),
				                      new object [] { checkbox, state });
				return;
			}

			// NOTE: We can count on presence of InvokeOnClick;
			//       it is a protected member of CheckBox.
			//

		}
		#endregion
	}
	
	delegate void PerformToggleDelegate (SWF.CheckBox checkbox, SWF.CheckState state);
}




		
		public void Invoke ()
		{
			if (Provider.Control.InvokeSync (b => !b.Enabled))
				throw new ElementNotEnabledException ();
			
			PerformComboBoxClick ((SWF.ComboBox) Provider.Control);
		}
		
		#endregion	

			SWF.ComboBox combobox = (SWF.ComboBox) Provider.Control;
			combobox.InvokeSync (delegate {
				combobox.DroppedDown = !combobox.DroppedDown;
			});
	        if (Provider.Control.InvokeRequired == true) {
	            Provider.Control.BeginInvoke (new PerformComboBoxClickDelegate (PerformComboBoxClick),
				                              new object [] { combobox });
	            return;
	        }
			combobox.DroppedDown = !combobox.DroppedDown;
		}
		
		#endregion	
	}
	
	delegate void PerformComboBoxClickDelegate (SWF.ComboBox combobox);
}

Lines 79-122 namespace Mono.UIAutomation.Winforms.Behaviors.ComboBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ComboBox/ExpandCollapseProviderBehavior.cs (-23 / +18 lines)
79		79
80	public ExpandCollapseState ExpandCollapseState {	80	public ExpandCollapseState ExpandCollapseState {
81	get {	81	get {
82	return ((SWF.ComboBox) Provider.Control).DroppedDown ? ExpandCollapseState.Expanded	82	SWF.ComboBox combobox = (SWF.ComboBox) Provider.Control;
83	: ExpandCollapseState.Collapsed;	83	if (combobox.InvokeSync (c => c.DroppedDown))
		84	return ExpandCollapseState.Expanded;
		85	else
		86	return ExpandCollapseState.Collapsed;
84	}	87	}
85	}	88	}
86		89
87	public void Collapse ()	90	public void Collapse ()
88	{	91	{
89	if (Provider.Control.Enabled == false)	92	SWF.ComboBox combobox = (SWF.ComboBox) Provider.Control;
		93
		94	if (combobox.InvokeSync (c => !c.Enabled))
90	throw new ElementNotEnabledException ();	95	throw new ElementNotEnabledException ();
91		96
92	PerformExpandOrCollapse ((SWF.ComboBox) Provider.Control, false);	97	combobox.InvokeSync (delegate {
		98	combobox.DroppedDown = false;
		99	});
93	}	100	}
94		101
95	public void Expand ()	102	public void Expand ()
96	{	103	{
97	if (Provider.Control.Enabled == false)	104	SWF.ComboBox combobox = (SWF.ComboBox) Provider.Control;
98	throw new ElementNotEnabledException ();
99		105
100	PerformExpandOrCollapse ((SWF.ComboBox) Provider.Control, true);	106	if (combobox.InvokeSync (c => !c.Enabled))
101	}	107	throw new ElementNotEnabledException ();
102		108
103	#endregion	109	combobox.InvokeSync (delegate {
104		110	combobox.DroppedDown = true;
105	#region Private Methods	111	});
106
107	private void PerformExpandOrCollapse (SWF.ComboBox combobox, bool droppedDown)
108	{
109	if (combobox.InvokeRequired == true) {
110	combobox.BeginInvoke (new PerformExpandOrCollapseDelegate (PerformExpandOrCollapse),
111	new object [] { combobox, droppedDown } );
112	return;
113	}
114	combobox.DroppedDown = droppedDown;
115	}	112	}
116		113
117	#endregion	114	#endregion
118		115
119	}	116	}
120
121	delegate void PerformExpandOrCollapseDelegate (SWF.ComboBox combobox, bool droppedDown);
122	}	117	}

Lines 70-76 namespace Mono.UIAutomation.Winforms.Behaviors.ComboBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ComboBox/ListBoxSelectionProviderBehavior.cs (-5 / +3 lines)
70	#region ISelectionProvider Members	70	#region ISelectionProvider Members
71		71
72	public override bool IsSelectionRequired {	72	public override bool IsSelectionRequired {
73	get { return ((SWF.ComboBox) provider.Control).SelectedIndex != -1; }	73	get {
		74	return ((SWF.ComboBox) Provider.Control).InvokeSync (c => c.SelectedIndex != -1);
		75	}
74	}	76	}
75		77
76	public override IRawElementProviderSimple[] GetSelection ()	78	public override IRawElementProviderSimple[] GetSelection ()
Lines 79-89 namespace Mono.UIAutomation.Winforms.Behaviors.ComboBox Link Here
79	}	81	}
80		82
81	#endregion	83	#endregion
82
83	#region Private Fields
84		84
85	private ComboBoxProvider provider;	85	private ComboBoxProvider provider;
86
87	#endregion
88	}	86	}
89	}	87	}

Lines 95-101 namespace Mono.UIAutomation.Winforms.Behaviors.ComboBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ComboBox/SelectionProviderBehavior.cs (-1 / +3 lines)
95	}	95	}
96		96
97	public virtual bool IsSelectionRequired {	97	public virtual bool IsSelectionRequired {
98	get { return ((SWF.ComboBox) Provider.Control).SelectedIndex != -1; }	98	get {
		99	return ((SWF.ComboBox) Provider.Control).InvokeSync (c => c.SelectedIndex != -1);
		100	}
99	}	101	}
100		102
101	public virtual IRawElementProviderSimple[] GetSelection ()	103	public virtual IRawElementProviderSimple[] GetSelection ()




		#region IValueProvider Interface
		
		public bool IsReadOnly {
			get { return Provider.Control.InvokeSync (c => !c.Enabled); }
		}

		public string Value {
			get { return Provider.Control.InvokeSync (c => c.Text); }
		}

		public void SetValue (string value)

			if (IsReadOnly == true)
				throw new ElementNotEnabledException ();

			Provider.Control.InvokeSync (delegate {
				Provider.Control.Text = value;
			});
		}

		#endregion
		
		#region Private Methods
		
		private void PerformSetValue (string value) 
		{
			if (Provider.Control.InvokeRequired == true) {
				Provider.Control.BeginInvoke (new ComboBoxSetValueDelegate (PerformSetValue),
				                              new object [] { value } );
				return;
			}
			
			Provider.Control.Text = value;
		}
		
		#endregion
	}

	delegate void ComboBoxSetValueDelegate (string value);
}

Lines 67-79 namespace Mono.UIAutomation.Winforms.Behaviors.DataGrid Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/DataGrid/CustomInvokeProviderBehavior.cs (-5 / +7 lines)
67		67
68	public void Invoke ()	68	public void Invoke ()
69	{	69	{
70	if (!customProvider.DataGridProvider.Control.Enabled)	70	if (customProvider.DataGridProvider.Control.InvokeSync (c => !c.Enabled))
71	throw new ElementNotEnabledException ();	71	throw new ElementNotEnabledException ();
72		72
73	if (customProvider.DataGridProvider.DataGrid.IsExpanded (customProvider.Row))	73	customProvider.DataGridProvider.DataGrid.InvokeSync (delegate {
74	customProvider.DataGridProvider.DataGrid.Collapse (customProvider.Row);	74	if (customProvider.DataGridProvider.DataGrid.IsExpanded (customProvider.Row))
75	else	75	customProvider.DataGridProvider.DataGrid.Collapse (customProvider.Row);
76	customProvider.DataGridProvider.DataGrid.Expand (customProvider.Row);	76	else
		77	customProvider.DataGridProvider.DataGrid.Expand (customProvider.Row);
		78	});
77	}	79	}
78		80
79	#endregion	81	#endregion




			// words an editable style doesn't necessarily mean that you can 
			// set the value. In Vista Wwhen the cell is not editable and you call
			// SetValue it will throw an exception so, we are swallowing all the exceptions.

			provider.ItemProvider.Control.InvokeSync (delegate {
	 			try {
					provider.ItemProvider.SetEditValue (provider, value);
				} catch (Exception e) {
					// DataSource may throw any exception.
					Log.Warn ("{0}: Caught exception:\n{1}", this.GetType (), e);
				}
			});
		}
		
		public bool IsReadOnly {
			get { return false; }
		}
		
		public string Value {


		#region Private Methods

		private void PerformSetValue (string value)
		{
			if (IsReadOnly)
				throw new ElementNotEnabledException ();

			if (provider.ItemProvider.Control.InvokeRequired) {
				provider.ItemProvider.Control.BeginInvoke (new DataItemSetValueDelegate (PerformSetValue),
				                                           new object [] { value } );
				return;
			}
			
		 	try {
				provider.ItemProvider.SetEditValue (provider, value);
			} catch (Exception e) {
				// DataSource may throw any exception.
				Log.Warn ("{0}: Caught exception:\n{1}", this.GetType (), e);
			}
		}

		#endregion

		#region Private Methods

		private DataGridProvider.DataGridDataItemEditProvider provider;
		
		#endregion




			// words an editable style doesn't necessarily mean that you can 
			// set the value. In Vista Wwhen the cell is not editable and you call
			// SetValue it will throw an exception so, we are swallowing all the exceptions.
			provider.Control.InvokeSync (delegate {
			 	try {
					provider.Value = value;
				} catch (Exception e) {
					// DataSource may throw any exception.
					Log.Warn ("{0}: Caught exception:\n{1}", this.GetType (), e);
				}
			});
		}
		
		public bool IsReadOnly {


		#region Private Methods

		private void PerformSetValue (string value)
		{
			if (provider.Control.InvokeRequired) {
				provider.Control.BeginInvoke (new DataItemSetValueDelegate (PerformSetValue),
				                              new object [] { value } );
				return;
			}
		 	try {
				provider.Value = value;
			} catch (Exception e) {
				// DataSource may throw any exception.
				Log.Warn ("{0}: Caught exception:\n{1}", this.GetType (), e);
			}
		}

		#endregion

		#region Private Methods

		private DataGridProvider.DataGridDataItemProvider provider;
		
		#endregion




		
		public void Invoke ()
		{
			if (dataGrid.InvokeSync (b => !b.Enabled || !b.AllowSorting || !b.ColumnHeadersVisible))
				throw new ElementNotEnabledException ();

			PerformClick ();
		}
		
		#endregion	
		
		#region Private Members
		
		private void PerformClick ()
		{
			if (dataGrid.InvokeRequired) {
				dataGrid.BeginInvoke (new SWF.MethodInvoker (PerformClick));
				return;
			}

			// FIXME: We need to replace reflection with an internal method in SWF.DataGrid
			MethodInfo methodInfo = typeof (SWF.DataGrid).GetMethod ("OnMouseDown",
			                                                          BindingFlags.InvokeMethod

			                                        (int) rect.Y,
			                                        (int) rect.Width, 
			                                        (int) rect.Height);
			dataGrid.InvokeSync (delegate {
				sdRect = dataGrid.RectangleToClient (sdRect);
	
				Action<SWF.DataGrid, SWF.MouseEventArgs> mouseDownMethod
					= (Action<SWF.DataGrid, SWF.MouseEventArgs>) Delegate.CreateDelegate 
						(typeof (Action<SWF.DataGrid, SWF.MouseEventArgs>), methodInfo);
	
				SWF.MouseEventArgs args 
					= new SWF.MouseEventArgs (SWF.MouseButtons.Left,
					                          1,
					                          sdRect.X + 2,
					                          sdRect.Y + 2,
					                          0);
				mouseDownMethod (dataGrid, args);
			});
		}

		private SWF.DataGrid dataGrid;		




			if (provider.Cell.ReadOnly)
				throw new ElementNotEnabledException ();

			provider.ItemProvider.DataGridView.InvokeSync (delegate {
				SWF.DataGridViewCellEventArgs args
					= new SWF.DataGridViewCellEventArgs (provider.Cell.ColumnIndex, 
					                                     provider.Cell.RowIndex);
				provider.ItemProvider.DataGridView.InternalOnCellContentClick (args);
			});
		
		private void PerformClick ()
		{
			if (provider.ItemProvider.DataGridView.InvokeRequired) {
				provider.ItemProvider.DataGridView.BeginInvoke (new SWF.MethodInvoker (PerformClick));
				return;
			}

			SWF.DataGridViewCellEventArgs args
				= new SWF.DataGridViewCellEventArgs (provider.Cell.ColumnIndex, 
				                                     provider.Cell.RowIndex);
			provider.ItemProvider.DataGridView.InternalOnCellContentClick (args);
		}
		
		#endregion





		public ToggleState ToggleState {
			get {
				return provider.ItemProvider.DataGridView.InvokeSync (d => {
					// More information: 
					// http://msdn.microsoft.com/en-us/library/system.windows.forms.datagridviewcheckboxcell.valuetype.aspx
						
					if (provider.CheckBoxCell.Value == null) {
						if (provider.CheckBoxCell.ThreeState)
							return ToggleState.Indeterminate;
						else
							return ToggleState.Off;
					} else {
						SWF.CheckState state = SWF.CheckState.Indeterminate;
						bool tryBoolean = false;
						state = (SWF.CheckState) provider.CheckBoxCell.Value;
					} catch (InvalidCastException) { tryBoolean = true; }

					if (tryBoolean) {
						try {
							state = (SWF.CheckState) provider.CheckBoxCell.Value;
						} catch (InvalidCastException) { tryBoolean = true; }
	
						if (tryBoolean) {
							try {
								bool val = (bool) provider.CheckBoxCell.Value;
								if (val)
									state = SWF.CheckState.Checked;
								else
									state = SWF.CheckState.Unchecked;
							} catch (InvalidCastException) {
								// We just can't get valid value
								return ToggleState.Indeterminate;
							}
						}
	
						switch (state) {
						case SWF.CheckState.Checked:
							return ToggleState.On;
						case SWF.CheckState.Unchecked:
							return ToggleState.Off;
						case SWF.CheckState.Indeterminate:
							return ToggleState.Indeterminate;
						}
						

					switch (state) {
					case SWF.CheckState.Checked:
						return ToggleState.On;
					case SWF.CheckState.Unchecked:
						return ToggleState.Off;
					case SWF.CheckState.Indeterminate:
					default:
						return ToggleState.Indeterminate;
					}
				});
				}
			}
		}


		
		private void PerformToggle (SWF.CheckState state)
		{
			provider.ItemProvider.DataGridView.InvokeSync (delegate {
				// FIXME: Validate InvalidCastException ? (thrown usually because of ValueType)
	
				SWF.DataGridViewCell oldCell = provider.ItemProvider.DataGridView.CurrentCell;
				provider.ItemProvider.DataGridView.CurrentCell = provider.CheckBoxCell;
	//			provider.ItemProvider.DataGridView.BeginEdit (false);
				provider.CheckBoxCell.Value = state;
	//			provider.ItemProvider.DataGridView.EndEdit ();
				provider.ItemProvider.DataGridView.CurrentCell = oldCell;
			});
//			provider.ItemProvider.DataGridView.BeginEdit (false);
			provider.CheckBoxCell.Value = state;
//			provider.ItemProvider.DataGridView.EndEdit ();
			provider.ItemProvider.DataGridView.CurrentCell = oldCell;
		}

		#endregion

Lines 87-130 namespace Mono.UIAutomation.Winforms.Behaviors.DataGridView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/DataGridView/DataItemChildValueProviderBehavior.cs (-27 / +18 lines)
87	if (IsReadOnly)	87	if (IsReadOnly)
88	throw new ElementNotEnabledException ();	88	throw new ElementNotEnabledException ();
89		89
90	PerformSetValue (value);	90	provider.ItemProvider.DataGridView.InvokeSync (delegate {
		91	// Notice however that this is the weird behavior in .NET, because
		92	// editing an IsNewRow Row WONT ADD a new row
		93
		94	SWF.DataGridViewCell oldCell = provider.ItemProvider.DataGridView.CurrentCell;
		95	provider.ItemProvider.DataGridView.CurrentCell = provider.TextBoxCell;
		96	provider.TextBoxCell.Value = value;
		97	provider.ItemProvider.DataGridView.CurrentCell = oldCell;
		98	});
91	}	99	}
92		100
93	public bool IsReadOnly {	101	public bool IsReadOnly {
94	get { return provider.TextBoxCell.ReadOnly; }	102	get {
		103	return provider.ItemProvider.DataGridView.InvokeSync (c => provider.TextBoxCell.ReadOnly);
		104	}
95	}	105	}
96		106
97	public string Value {	107	public string Value {
98	get { return provider.TextBoxCell.Value as string ?? string.Empty; }	108	get {
		109	return provider.ItemProvider.DataGridView.InvokeSync (c => provider.TextBoxCell.Value as string ?? string.Empty);
		110	}
99	}	111	}
100		112
101	#endregion	113	#endregion
102
103	#region Private Members
104		114
105	private void PerformSetValue (string value)	115	#region Private fields
106	{	116
107	if (provider.ItemProvider.DataGridView.InvokeRequired) {
108	provider.ItemProvider.DataGridView.BeginInvoke (new SetValueDelegate (PerformSetValue),
109	new object [] { value });
110	return;
111	}
112
113	// Notice however that this is the weird behavior in .NET, because
114	// editing an IsNewRow Row WONT ADD a new row
115
116	SWF.DataGridViewCell oldCell = provider.ItemProvider.DataGridView.CurrentCell;
117	provider.ItemProvider.DataGridView.CurrentCell = provider.TextBoxCell;
118	provider.TextBoxCell.Value = value;
119	provider.ItemProvider.DataGridView.CurrentCell = oldCell;
120	}
121
122
123	private DataGridViewProvider.DataGridViewDataItemEditProvider provider;	117	private DataGridViewProvider.DataGridViewDataItemEditProvider provider;
124		118
125	private delegate void SetValueDelegate (string val);
126
127	#endregion	119	#endregion
128
129	}	120	}
130	}	121	}




		
		public void Invoke ()
		{
			if (provider.ComboBoxProvider.ItemProvider.DataGridView.InvokeSync (d => provider.ComboBoxProvider.ComboBoxCell.ReadOnly))
				throw new ElementNotEnabledException ();

			provider.ComboBoxProvider.ItemProvider.DataGridView.InvokeSync (delegate {
				SWF.DataGridViewCellEventArgs args
					= new SWF.DataGridViewCellEventArgs (provider.ComboBoxProvider.Cell.ColumnIndex, 
					                                     provider.ComboBoxProvider.Cell.RowIndex);
				provider.ComboBoxProvider.ItemProvider.DataGridView.InternalOnCellContentClick (args);
			});
		}
		
		#endregion
		
		#region Private Methods
		
		#region Private fields
		{
			if (provider.ComboBoxProvider.ItemProvider.DataGridView.InvokeRequired) {
				provider.ComboBoxProvider.ItemProvider.DataGridView.BeginInvoke (new SWF.MethodInvoker (PerformClick));
				return;
			}

			SWF.DataGridViewCellEventArgs args
				= new SWF.DataGridViewCellEventArgs (provider.ComboBoxProvider.Cell.ColumnIndex, 
				                                     provider.ComboBoxProvider.Cell.RowIndex);
			provider.ComboBoxProvider.ItemProvider.DataGridView.InternalOnCellContentClick (args);
		}
		
		#endregion

		#region Private Methods

		private DataGridViewProvider.DataGridViewDataItemComboBoxButtonProvider provider;
		
		#endregion
		
	}




		
		public ExpandCollapseState ExpandCollapseState {
			get {
				if (lastComboBox == null 
				    || lastComboBox.InvokeSync (c => !c.DroppedDown))
					return ExpandCollapseState.Collapsed;
				else 
					return ExpandCollapseState.Expanded;


		public void Collapse ()
		{
			if (provider.ItemProvider.DataGridView.InvokeSync (c => provider.ComboBoxCell.ReadOnly))
				throw new ElementNotEnabledException ();

			PerformExpandOrCollapse (false);


		public void Expand ()
		{
			if (provider.ItemProvider.DataGridView.InvokeSync (c => provider.ComboBoxCell.ReadOnly))
				throw new ElementNotEnabledException ();
			
			PerformExpandOrCollapse (true);


		private void PerformExpandOrCollapse (bool expand)
		{
			provider.ItemProvider.DataGridView.InvokeSync (delegate {
				SWF.DataGridViewCell oldCell = provider.ItemProvider.DataGridView.CurrentCell;
				provider.ItemProvider.DataGridView.CurrentCell = provider.ComboBoxCell;
				provider.ItemProvider.DataGridView.BeginEdit (false);
	
				SWF.ComboBox combobox = provider.ItemProvider.DataGridView.EditingControl as SWF.ComboBox;
				if (combobox != null) {
					// We we'll basically are keeping a reference to the EditingControl
					// to listen for DroppedDown event and set it when it changes.
					if (lastComboBox != combobox)
						expandCollapseEvent.CurrentComboBox = combobox;
					
					lastComboBox = combobox;
					lastComboBox.DroppedDown = expand;
				} else
	
				provider.ItemProvider.DataGridView.EndEdit ();
				provider.ItemProvider.DataGridView.CurrentCell = oldCell;
			});
			} else

			provider.ItemProvider.DataGridView.EndEdit ();
			provider.ItemProvider.DataGridView.CurrentCell = oldCell;
		}

		private DataItemComboBoxExpandCollapsePatternStateEvent expandCollapseEvent;
		private SWF.ComboBox lastComboBox;
		private DataGridViewProvider.DataGridViewDataItemComboBoxProvider provider;

		private delegate void ExpandOrCollapseDelegate (bool expand);

		#endregion
		
	}




		#region IGridProvider implementation

		public int ColumnCount {
			get { return gridviewprovider.DataGridView.InvokeSync (v => v.Columns.Count); }
		}

		public int RowCount {
			get { return gridviewprovider.DataGridView.InvokeSync (v => v.Rows.Count); }
		}

		public IRawElementProviderSimple GetItem (int row, int column)

			if (row < 0 || column < 0 || row >= RowCount || column >= ColumnCount)
			    throw new ArgumentOutOfRangeException ();

			return gridviewprovider.DataGridView.InvokeSync (d => {
				DataGridViewProvider.DataGridDataItemProvider item 
					= (DataGridViewProvider.DataGridDataItemProvider) gridviewprovider.GetItemProviderFrom (gridviewprovider,
					                                                                                        d.Rows [row],
					                                                                                        false);
				SWF.DataGridViewColumn viewColumn = d.Columns [column];
				return item.GetChildItem (viewColumn);
			});
		}
		
		#endregion




		
		public void Invoke ()
		{
			if (dataGridView.InvokeSync (b => !b.Enabled))
				throw new ElementNotEnabledException ();
			
			dataGridView.InvokeSync (delegate {
				// FIXME: We need to replace reflection with an internal method in SWF.DataGridView
				MethodInfo methodInfo = typeof (SWF.DataGridView).GetMethod ("OnMouseClick",
				                                                             BindingFlags.InvokeMethod
				                                                             | BindingFlags.NonPublic
				                                                             | BindingFlags.Instance);
				Rect rect = itemProvider.BoundingRectangle;
	
				SD.Rectangle sdRect = new SD.Rectangle ((int) rect.X, 
				                                        (int) rect.Y,
				                                        (int) rect.Width, 
				                                        (int) rect.Height);
				sdRect = dataGridView.RectangleToClient (sdRect);
	
				Action<SWF.DataGridView, SWF.MouseEventArgs> mouseClickMethod
					= (Action<SWF.DataGridView, SWF.MouseEventArgs>) Delegate.CreateDelegate 
						(typeof (Action<SWF.DataGridView, SWF.MouseEventArgs>), methodInfo);
	
				SWF.MouseEventArgs args 
					= new SWF.MouseEventArgs (SWF.MouseButtons.Left,
					                          1,
					                          (int) (sdRect.X + sdRect.Width / 2),
					                          (int) (sdRect.Y + sdRect.Height / 2),
					                          0);
				mouseClickMethod (dataGridView, args);
			});

			Action<SWF.DataGridView, SWF.MouseEventArgs> mouseClickMethod
				= (Action<SWF.DataGridView, SWF.MouseEventArgs>) Delegate.CreateDelegate 
					(typeof (Action<SWF.DataGridView, SWF.MouseEventArgs>), methodInfo);

			SWF.MouseEventArgs args 
				= new SWF.MouseEventArgs (SWF.MouseButtons.Left,
				                          1,
				                          (int) (sdRect.X + sdRect.Width / 2),
				                          (int) (sdRect.Y + sdRect.Height / 2),
				                          0);
			mouseClickMethod (dataGridView, args);
		}

		private SWF.DataGridView dataGridView;		




#region IInvokeProvider Members
		public virtual void Invoke ()
		{
			if (Provider.Control.InvokeSync (c => !c.Enabled))
				throw new ElementNotEnabledException ();

			Provider.Control.InvokeSync (delegate {
				((SWF.DateTimePicker) dateTimePicker.Control)
					.DropDownButtonClicked ();
			});
#region Private Methods
		private void PerformClick ()
		{
			if (Provider.Control.InvokeRequired) {
				Provider.Control.BeginInvoke (
					new SWF.MethodInvoker (PerformClick));
				return;
			}

			((SWF.DateTimePicker) dateTimePicker.Control)
				.DropDownButtonClicked ();
		}
#endregion
		
#region Private Fields
		private DateTimePickerProvider dateTimePicker;
#endregion
	}

}




	
#region IRangeValueProvider Members
		public bool IsReadOnly {
			get { return dateTimePicker.InvokeSync (b => b.ShowCheckBox && !b.Checked); }
				return (dateTimePicker.ShowCheckBox
				        && !dateTimePicker.Checked);
			}
		}
		
		public double Minimum {
			get {
				DateTime min = dateTimePicker.InvokeSync (v => v.MinDate);
				DateTime cur = dateTimePicker.InvokeSync (v => v.Value);
				
				switch (partProvider.PartData.date_time_part) {
				case SWF.DateTimePicker.DateTimePart.Seconds:
					return IsDateEqual (min, cur) ? min.Second : 0;

		
		public double Maximum {
			get {
				DateTime max = dateTimePicker.InvokeSync (c => c.MaxDate);
				DateTime cur = dateTimePicker.InvokeSync (c => c.Value);
				switch (partProvider.PartData.date_time_part) {
				case SWF.DateTimePicker.DateTimePart.Seconds:
					return IsDateEqual (max, cur) ? max.Second : 60;

			if (value < Minimum || value > Maximum)
				throw new ArgumentOutOfRangeException ();

			PerformSetValue (value);
		}
#endregion
		
#region Private Methods
		private void PerformSetValue (double value) 
		{
			if (IsReadOnly)
				throw new ElementNotEnabledException ();

			dateTimePicker.InvokeSync (delegate {
				dateTimePicker.SetPart ((int) value, partProvider.PartData.date_time_part);
			});
					new object [] { value }
				);
				return;
			}

			dateTimePicker.SetPart ((int) value, partProvider.PartData.date_time_part);
		}

		private bool IsDateEqual (DateTime date1, DateTime date2)

#endregion
	}

	public delegate void DateTimePickerPartSetValueDelegate (double value);
}




#region IToggleProvider Members
		public ToggleState ToggleState {
			get {
				return dateTimePicker.InvokeSync (c => c.Checked) ? ToggleState.On
			                                      : ToggleState.Off;
			}
		}

		public void Toggle ()
		{
			if (dateTimePicker.InvokeSync (b => !b.Enabled))
				throw new ElementNotEnabledException ();

			dateTimePicker.InvokeSync (delegate {
				dateTimePicker.Checked = !dateTimePicker.Checked;
			});
		
#region Private Methods
		private void PerformToggle ()
		{
			if (Provider.Control.InvokeRequired) {
				Provider.Control.BeginInvoke (
					new SWF.MethodInvoker (PerformToggle));
				return;
			}

			dateTimePicker.Checked = !dateTimePicker.Checked;
		}
#endregion





	
		public bool CanMove {
			get {
				return form.InvokeSync (f => f.WindowState == SWF.FormWindowState.Normal);
			}
		}

		public bool CanResize {
			get {
				switch (form.InvokeSync (f => f.FormBorderStyle)) {
				case SWF.FormBorderStyle.Fixed3D:
				case SWF.FormBorderStyle.FixedDialog:
				case SWF.FormBorderStyle.FixedSingle:

			//       exceptions are thrown with bad input
			if (!CanMove)
				throw new InvalidOperationException ("CanMove is false");

			form.InvokeSync (delegate {
				form.Location = new Point ((int) x, (int) y);
			});
				return;
			}
			
			form.Location = new Point ((int) x, (int) y);
		}

		public void Resize (double width, double height)

			//       exceptions are thrown with bad input
			if (!CanResize)
				throw new InvalidOperationException ("CanResize is false");

			form.InvokeSync (delegate { 
				form.Size = new Size ((int) width, (int) height);
			});
				return;
			}
			
			form.Size = new Size ((int) width, (int) height);
		}

		public void Rotate (double degrees)

		#endregion
		
	}
	
	delegate void PerformTransformDelegate (double width, double height);

}




		
		public void SetVisualState (WindowVisualState state)
		{
			SWF.FormWindowState newState = form.InvokeSync (f => f.WindowState);
			switch (state) {
			case WindowVisualState.Maximized:
				newState = SWF.FormWindowState.Maximized;

				newState = SWF.FormWindowState.Normal;
				break;
			}

			form.InvokeSync (delegate { form.WindowState = newState; });
		}
		
		public void Close ()
		{
			form.InvokeSync (delegate { form.Close (); });
		}
		
		public bool Minimizable {
			get { return form.InvokeSync (f => f.MinimizeBox); }
				return form.MinimizeBox;
			}
		}
		
		public bool Maximizable {
			get { return form.InvokeSync (f => f.MaximizeBox); }
				return form.MaximizeBox;
			}
		}
		
		public bool IsTopmost {
			get { return form.InvokeSync (f => f.TopMost); }
				return form.TopMost;
			}
		}
		
		public bool IsModal {
			get { return form.InvokeSync (f => f.Modal); }
				return form.Modal;
			}
		}
		
		public WindowInteractionState InteractionState {

		
		public WindowVisualState VisualState {
			get {
				switch (form.InvokeSync (f => f.WindowState)) {
				case SWF.FormWindowState.Maximized:
					return WindowVisualState.Maximized;
				case SWF.FormWindowState.Minimized:

		
		#endregion
		
		#region Private Methods
		
		private void PerformSetVisualState (SWF.Form form, SWF.FormWindowState state)
		{
			if (form.InvokeRequired == true) {
				form.BeginInvoke (new PerformSetVisualStateDelegate (PerformSetVisualState),
				                  new object [] { form, state });
				return;
			}
			form.WindowState = state;
		}
		
		#endregion
		
		#region Private Fields

		private bool closing;

		#endregion
	}
	
	delegate void PerformSetVisualStateDelegate (SWF.Form form, SWF.FormWindowState state);
	
}

Lines 102-111 namespace Mono.UIAutomation.Winforms.Behaviors.Generic Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/Generic/ScrollProviderBehavior.cs (-32 / +35 lines)
102	//FIXME: This MUST BE locale-specific	102	//FIXME: This MUST BE locale-specific
103	public double HorizontalScrollPercent {	103	public double HorizontalScrollPercent {
104	get {	104	get {
105	if (HorizontallyScrollable == false \|\| hscrollbar.Maximum == 0)	105	if (HorizontallyScrollable == false)
106	return ScrollPatternIdentifiers.NoScroll;	106	return ScrollPatternIdentifiers.NoScroll;
107	else	107	else {
108	return (hscrollbar.Value * 100) / hscrollbar.Maximum;	108	return hscrollbar.InvokeSync (c => {
		109	if (c.Maximum == 0)
		110	return ScrollPatternIdentifiers.NoScroll;
		111	else
		112	return (double) ((c.Value * 100) / c.Maximum);
		113	});
		114	}
109	}	115	}
110	}	116	}
111		117
Lines 128-137 namespace Mono.UIAutomation.Winforms.Behaviors.Generic Link Here
128	//FIXME: This MUST BE locale-specific	134	//FIXME: This MUST BE locale-specific
129	public double VerticalScrollPercent {	135	public double VerticalScrollPercent {
130	get {	136	get {
131	if (VerticallyScrollable == false \|\| vscrollbar.Maximum == 0)	137	if (VerticallyScrollable == false)
132	return ScrollPatternIdentifiers.NoScroll;	138	return ScrollPatternIdentifiers.NoScroll;
133	else	139	else {
134	return (vscrollbar.Value * 100) / vscrollbar.Maximum;	140	return vscrollbar.InvokeSync (c => {
		141	if (c.Maximum == 0)
		142	return ScrollPatternIdentifiers.NoScroll;
		143	else
		144	return (double) ((c.Value * 100) / c.Maximum);
		145	});
		146	}
135	}	147	}
136	}	148	}
137		149
Lines 164-178 namespace Mono.UIAutomation.Winforms.Behaviors.Generic Link Here
164	if (horizontalPercent != ScrollPatternIdentifiers.NoScroll) {	176	if (horizontalPercent != ScrollPatternIdentifiers.NoScroll) {
165	if (horizontalPercent < 0 \|\| horizontalPercent > 100)	177	if (horizontalPercent < 0 \|\| horizontalPercent > 100)
166	throw new ArgumentOutOfRangeException ();	178	throw new ArgumentOutOfRangeException ();
167	else	179	else {
168	PerformScrollByPercent (hscrollbar, (int) ((horizontalPercent * hscrollbar.Maximum) / 100));	180	double maximum = hscrollbar.InvokeSync (h => h.Maximum);
		181	hscrollbar.InvokeSync (delegate {
		182	hscrollbar.Value = (int) ((horizontalPercent * maximum) / 100);
		183	});
		184	}
169	}	185	}
170		186
171	if (verticalPercent != ScrollPatternIdentifiers.NoScroll) {	187	if (verticalPercent != ScrollPatternIdentifiers.NoScroll) {
172	if (verticalPercent < 0 \|\| verticalPercent > 100)	188	if (verticalPercent < 0 \|\| verticalPercent > 100)
173	throw new ArgumentOutOfRangeException ();	189	throw new ArgumentOutOfRangeException ();
174	else	190	else {
175	PerformScrollByPercent (vscrollbar, (int) ((verticalPercent * vscrollbar.Maximum) / 100));	191	double maximum = vscrollbar.InvokeSync (v => v.Maximum);
		192	hscrollbar.InvokeSync (delegate {
		193	vscrollbar.Value = (int) ((verticalPercent * maximum) / 100);
		194	});
		195	}
176	}	196	}
177	}	197	}
178		198
Lines 222-249 namespace Mono.UIAutomation.Winforms.Behaviors.Generic Link Here
222	invoke	242	invoke
223	= (Action<SWF.ScrollBar>) Delegate.CreateDelegate (typeof (Action<SWF.ScrollBar>),	243	= (Action<SWF.ScrollBar>) Delegate.CreateDelegate (typeof (Action<SWF.ScrollBar>),
224	methodInfo);	244	methodInfo);
225	PerformScrollByAmount (scrollbar);	245
226	}	246	scrollbar.InvokeSync (delegate {
227		247	invoke (scrollbar);
228	private void PerformScrollByAmount (SWF.ScrollBar scrollbar)	248	invoke = null;
229	{	249	});
230	if (scrollbar.InvokeRequired == true) {
231	scrollbar.BeginInvoke (new ScrollByAmountDelegate (PerformScrollByAmount),
232	new object [] { scrollbar });
233	return;
234	}
235	invoke (scrollbar);
236	invoke = null;
237	}
238
239	private void PerformScrollByPercent (SWF.ScrollBar scrollbar, int value)
240	{
241	if (scrollbar.InvokeRequired == true) {
242	scrollbar.BeginInvoke (new ScrollByPercentDelegate (PerformScrollByPercent),
243	new object [] { scrollbar, value });
244	return;
245	}
246	scrollbar.Value = value;
247	}	250	}
248		251
249	#endregion	252	#endregion




		{
			if (IsSelected)
				return;

			itemProvider.ContainerControl.InvokeSync (delegate {
				itemProvider.Select ();
			});
			}
			itemProvider.Select ();
		}

		public bool IsSelected {


		private void PerformUnselect ()
		{
			itemProvider.ContainerControl.InvokeSync (delegate {
				itemProvider.Unselect ();
			});
			}
			itemProvider.Unselect ();
		}
		
		private T itemProvider;




		#region IHypertext Specialization
		
		public int NumberOfLinks { 
			get { return linkLabel.InvokeSync (c => c.Links.Count); }
		}
		
		public int Start (int index) 
		{
			return linkLabel.InvokeSync (c => {
				if (index >= c.Links.Count || index < 0)
					return -1;
				else
					return c.Links [index].Start;
			});
		}
		
		public int Length (int index)
		{
			return linkLabel.InvokeSync (c => {
				if (index >= c.Links.Count || index < 0)
					return -1;
				else
					return c.Links [index].Length;
			});
		}
		
		public string Uri (int index)
		{
			return linkLabel.InvokeSync (c => {
				if (index >= c.Links.Count || index < 0)
					return null;
				else
					return c.Links [index].LinkData as string;
			});
		}
		
		public bool Enabled (int index)
		{
			return linkLabel.InvokeSync (c => {
				if (!c.Enabled || index >= c.Links.Count || index < 0)
					return false;
				else
					return c.Links [index].Enabled;
			});
		}
		
		public void Invoke (int index)

			if (!Enabled (index))
				throw new ElementNotEnabledException ();
			
			linkLabel.InvokeSync (c => {
				if (index >= c.Links.Count || index < 0)
					return;
	
				MethodInfo methodInfo = typeof (SWF.LinkLabel).GetMethod ("OnLinkClicked",
				                                                          BindingFlags.InvokeMethod
				                                                          | BindingFlags.NonPublic
				                                                          | BindingFlags.Instance);
				Action<SWF.LinkLabel, SWF.LinkLabelLinkClickedEventArgs> invokeMethod
					= (Action<SWF.LinkLabel, SWF.LinkLabelLinkClickedEventArgs>) Delegate.CreateDelegate 
						(typeof (Action<SWF.LinkLabel, SWF.LinkLabelLinkClickedEventArgs>),
						 methodInfo);
	
				SWF.LinkLabelLinkClickedEventArgs args 
					= new SWF.LinkLabelLinkClickedEventArgs (c.Links [index],
					                                         SWF.MouseButtons.Left);
				invokeMethod (c, args);
			});
			MethodInfo methodInfo = typeof (SWF.LinkLabel).GetMethod ("OnLinkClicked",
			                                                          BindingFlags.InvokeMethod
			                                                          | BindingFlags.NonPublic
			                                                          | BindingFlags.Instance);
			Action<SWF.LinkLabel, SWF.LinkLabelLinkClickedEventArgs> invokeMethod
				= (Action<SWF.LinkLabel, SWF.LinkLabelLinkClickedEventArgs>) Delegate.CreateDelegate 
					(typeof (Action<SWF.LinkLabel, SWF.LinkLabelLinkClickedEventArgs>),
					 methodInfo);

			SWF.LinkLabelLinkClickedEventArgs args 
				= new SWF.LinkLabelLinkClickedEventArgs (linkLabel.Links [index],
				                                         SWF.MouseButtons.Left);
			invokeMethod (linkLabel, args);
		}
		
		#endregion
	}
	
	delegate void PerformClickDelegate (int index);
}

Lines 92-102 namespace Mono.UIAutomation.Winforms.Behaviors.ListBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListBox/SelectionProviderBehavior.cs (-4 / +4 lines)
92	#region ISelectionProvider Members	92	#region ISelectionProvider Members
93		93
94	public bool CanSelectMultiple {	94	public bool CanSelectMultiple {
95	get {	95	get {
96	SWF.ListBox listBoxControl = (SWF.ListBox) Provider.Control;	96	SWF.ListBox listBoxControl = (SWF.ListBox) Provider.Control;
97		97
98	return listBoxControl.SelectionMode == SWF.SelectionMode.MultiExtended	98	return listBoxControl.InvokeSync (c => c.SelectionMode == SWF.SelectionMode.MultiExtended
99	\|\| listBoxControl.SelectionMode == SWF.SelectionMode.MultiSimple;	99	\|\| c.SelectionMode == SWF.SelectionMode.MultiSimple);
100	}	100	}
101	}	101	}
102		102




		
		public void ScrollIntoView ()
		{
			IListProvider itemProvider = ((ListItemProvider) Provider).ListProvider;
			itemProvider.Control.InvokeSync (delegate {
				itemProvider.ScrollItemIntoView ((ListItemProvider) Provider);
			});
		}

		#endregion
		
		#region Private Methods
		
		private void PerformScrollIntoView (IListProvider provider)
		{
			if (provider.Control.InvokeRequired == true) {
				provider.Control.BeginInvoke (new ScrollIntoViewDelegate (PerformScrollIntoView),
				                              new object [] { provider });
				return;
			}

			provider.ScrollItemIntoView ((ListItemProvider) Provider);
		}
		
		#endregion
	}
	
	delegate void ScrollIntoViewDelegate (ListProvider provider);
}




		public void Toggle ()
		{
			ListItemProvider provider = (ListItemProvider) Provider;

			provider.ListProvider.Control.InvokeSync (delegate {
				provider.ListProvider.ToggleItem (provider);
			});
			}
			
			provider.ListProvider.ToggleItem (provider);
		}

		#endregion





		public int ColumnCount {
			get {
				return listView.InvokeSync (c => {
					if (c.View == SWF.View.Details)
						return c.Columns.Count;
					else { //Is View.List
						if (RowCount == 0)
							return -1;
	
						bool module = c.Items.Count % RowCount > 0;
						return (c.Items.Count / RowCount) + (module ? 1 : 0);
					}
				});
			}
		}

		public int RowCount {
			get {
				return listView.InvokeSync (c => {
					if (c.View == SWF.View.Details)
						return c.Items.Count;
					else //Is View.List
						return c.UIARows;
				});
			}
		}



			ListViewProvider provider = (ListViewProvider) Provider;

			if (listView.InvokeSync (c => c.View == SWF.View.Details)) {
				// FIXME: In Vista when listView.Groups == 0 no Groups are added,
				// and we should iterate when listView.Groups > 0
				SWF.ListViewItem item = listView.Items [row];




		
		public int ColumnCount {
			get {
				return viewGroupProvider.ListView.InvokeSync (c => {
					if (viewGroupProvider.ListView.View == SWF.View.Details)
						return c.Columns.Count;
					else {
						int maxColums = c.UIAColumns;
						int itemsInGroup = ItemsInGroupCount ();
		
						if (itemsInGroup < maxColums)
							return itemsInGroup;
						else
							return maxColums;
					}
				});
			}
		}
		


		private int ItemsInGroupCount ()
		{
			return viewGroupProvider.ListView.InvokeSync (c => {
				ListViewProvider listViewProvider
					= (ListViewProvider) ProviderFactory.FindProvider (viewGroupProvider.ListView);
				if (listViewProvider.IsDefaultGroup (viewGroupProvider.Group) == true) {
					int itemsInGroup = 0;
					for (int index = 0; index < c.Items.Count; index++) {
						if (c.Items [index].Group == null)
							itemsInGroup++;
					}
					return itemsInGroup;
				} else
				return viewGroupProvider.Group.Items.Count;
			});
		}

		#endregion

Lines 70-79 namespace Mono.UIAutomation.Winforms.Behaviors.ListView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListView/HeaderItemInvokeProvider.cs (-4 / +2 lines)
70	#region IInvokeProvider implementation	70	#region IInvokeProvider implementation
71		71
72	public void Invoke ()	72	public void Invoke ()
73	{	73	{
74	var clickArgs = new SWF.ColumnClickEventArgs (	74	Log.Warn ("HeaderItemInvokePatternInvokedEvent: Invoke not implemented");
75	itemProvider.ColumnHeader.ListView.Columns.IndexOf (itemProvider.ColumnHeader));
76	itemProvider.ColumnHeader.ListView.OnColumnClick (clickArgs);
77	}	75	}
78		76
79	#endregion	77	#endregion




		public void Toggle ()
		{
			ListItemProvider provider = checkboxProvider.ItemProvider;

			provider.ListProvider.Control.InvokeSync (delegate {
				provider.ListProvider.ToggleItem (provider);
			});
			}
			
			provider.ListProvider.ToggleItem (provider);
		}

		#endregion




			position = (int) System.Math.Min (position, text.Length);

			string newValue = viewItem.Text.Insert (position, SWF.Clipboard.GetText ());
			viewItem.ListView.InvokeSync (delegate {
				viewItem.Text = newValue;
			});
		}

		#endregion

		#region Private Methods

		private void PerformSetValue (string value)
		{
			if (viewItem.ListView.InvokeRequired == true) {
				viewItem.ListView.BeginInvoke (new ListItemSetValueDelegate (PerformSetValue),
				                               new object [] { value } );
				return;
			}
			
			viewItem.Text = value;
		}

		#endregion
		
		#region Private Fields
		
		private SWF.ListViewItem viewItem;

		#endregion
	}

	delegate void ListItemSetValueDelegate (string value);
}




		public int Row {
			get {
				SWF.ListView listView = editProvider.ItemProvider.ListView;
				return listView.InvokeSync (c => c.Items.IndexOf (editProvider.ItemProvider.ListViewItem) );
			}
		}
		
		public int Column {
			get {
				SWF.ListView listView = editProvider.ItemProvider.ListView;
				return listView.InvokeSync (c => c.Columns.IndexOf (editProvider.ColumnHeader) );
			}
		}
		




		
		public void SetValue (string value)
		{
			int indexOf = listView.InvokeSync (l => l.Columns.IndexOf (columnHeader));

			if (indexOf < 0 || indexOf >= listViewItem.SubItems.Count)
				return;

			listView.InvokeSync (delegate {
				if (indexOf == 0)
					listViewItem.Text = value;
				else
					listViewItem.SubItems [indexOf - 1].Text = value;
			});
		}
		
		public bool IsReadOnly {
			get { return listView.InvokeSync (l => !l.LabelEdit); }
		}
		
		public string Value {
			get {
				return listView.InvokeSync (c => {
					int indexOf = c.Columns.IndexOf (columnHeader);
	
					if (indexOf < 0 || indexOf >= listViewItem.SubItems.Count)
						return string.Empty;
					else
						return listViewItem.SubItems [indexOf].Text;
				});
			}
		}
		
		#endregion

		#region Private Methods

		private void PerformSetValue (string value)
		{
			int indexOf = listView.Columns.IndexOf (columnHeader);

			if (indexOf < 0 || indexOf >= listViewItem.SubItems.Count)
				return;
			
			if (listView.InvokeRequired == true) {
				listView.BeginInvoke (new ListItemSetValueDelegate (PerformSetValue),
				                      new object [] { value } );
				return;
			}

			if (indexOf == 0)
				listViewItem.Text = value;
			else
				listViewItem.SubItems [indexOf - 1].Text = value;
		}

		#endregion
		
		#region Private Fields






using System;
using System.Windows;
using SWF = System.Windows.Forms;
using Mono.UIAutomation.Bridge;
using System.Windows.Automation;
using Mono.UIAutomation.Winforms;

			get {
				ListViewProvider.ListViewListItemProvider itemProvider 
					= (ListViewProvider.ListViewListItemProvider) Provider;
				SWF.ListViewItem item = itemProvider.ObjectItem as SWF.ListViewItem;
				if (item == null || item.ListView == null 
				    || (item.ImageIndex == -1 && item.ImageKey == string.Empty))
					return System.Windows.Rect.Empty;

				ImageList imageList = null;
				if (item.ListView.View == View.LargeIcon)
					imageList = item.ListView.LargeImageList;
				else
					imageList = item.ListView.SmallImageList;

				if (item == null || item.ListView == null)
					return System.Windows.Rect.Empty;

				return item.ListView.InvokeSync (c => {
				    if (item.ImageIndex == -1 && item.ImageKey == string.Empty)
						return System.Windows.Rect.Empty;

				if (itemProvider.CheckboxProvider != null) 
					rect.X += itemProvider.CheckboxProvider.BoundingRectangle.Width;

					SWF.ImageList imageList = null;
					if (c.View == SWF.View.LargeIcon)
						imageList = c.LargeImageList;
					else
						imageList = c.SmallImageList;
	
					if (imageList == null)
						return System.Windows.Rect.Empty;
	
					Rect rect = itemProvider.BoundingRectangle;
					rect.Width = imageList.ImageSize.Width;
					rect.Height = imageList.ImageSize.Height;
	
					if (itemProvider.CheckboxProvider != null) 
						rect.X += itemProvider.CheckboxProvider.BoundingRectangle.Width;
	
					return rect;
				});
			}
		}
		




			get { 
				SWF.ListView view = (SWF.ListView) viewProvider.Control;

				return view.InvokeSync (c => {
					if (c.View == SWF.View.List) //From Top to Bottom
						return MaxRows == 0 ? -1 : IndexOf % MaxRows;
					else if (c.View == SWF.View.Details)
						return itemProvider.Index;
					else //From Left to Right
					return MaxColumns == 0 ? -1 : IndexOf / MaxColumns;
				});
			}
		}
		

			get {
				SWF.ListView view = (SWF.ListView) viewProvider.Control;

				return view.InvokeSync (c => {
					if (c.View == SWF.View.List) //From Top to Bottom
						return MaxRows == 0 ? -1 : IndexOf / MaxRows;
					else if (c.View == SWF.View.Details) // Always 0
						return 0;
					else //From Left to Right
					return IndexOf - (Row * MaxColumns);
				});
			}
		}
		

			get {
				SWF.ListViewItem item = (SWF.ListViewItem) itemProvider.ObjectItem;

				return view.InvokeSync (c => {
					if (c.View == SWF.View.List || c.ShowGroups == false)
						return c.Items.IndexOf (item);
	
					if (viewProvider.IsDefaultGroup (group) == true) {					
						int indexOf = 0;
						bool found = false;					
						
						//TODO: Is this OK??
						for (int index = 0; index < c.Items.Count; index++) {
							if (c.Items [index].Group == null) {
								if (c.Items [index] == item) {
									found = true;
									break;
								}
								indexOf++;
							}
							indexOf++;
						}
						
						return found == false ? -1 : indexOf;
					} else
						return group.Items.IndexOf (item);
				});
			}
		}
		
		private int MaxColumns {
			get { return view.InvokeSync (v => v.UIAColumns); }
		}

		private int MaxRows {
			get { return view.InvokeSync (v => v.UIARows); }
		}
		
		#endregion




			if (IsReadOnly == true)
				throw new ElementNotEnabledException ();

			viewItem.ListView.InvokeSync (delegate {
				viewItem.Text = value;
			});
		}
		
		public bool IsReadOnly {
			get { return viewItem.ListView.InvokeSync (v => !v.LabelEdit); }
		}
		
		public string Value {

		}
		
		#endregion

		#region Private Methods

		private void PerformSetValue (string value)
		{
			if (viewItem.ListView.InvokeRequired == true) {
				viewItem.ListView.BeginInvoke (new ListItemSetValueDelegate (PerformSetValue),
				                               new object [] { value } );
				return;
			}
			
			viewItem.Text = value;
		}

		#endregion
		
		#region Private Fields
		

Lines 93-99 namespace Mono.UIAutomation.Winforms.Behaviors.ListView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListView/SelectionProviderBehavior.cs (-1 / +4 lines)
93	#region ISelectionProvider Members	93	#region ISelectionProvider Members
94		94
95	public bool CanSelectMultiple {	95	public bool CanSelectMultiple {
96	get { return ((SWF.ListView) Provider.Control).MultiSelect; }	96	get {
		97	SWF.ListView listview = (SWF.ListView) Provider.Control;
		98	return listview.InvokeSync (c => c.MultiSelect);
		99	}
97	}	100	}
98		101
99	public bool IsSelectionRequired {	102	public bool IsSelectionRequired {




		// rejected as it contains too many characters.
		public void InsertText (string str, ref int position)
		{
			if (maskedTextBox.InvokeSync (m => m.ReadOnly))
				throw new ElementNotEnabledException ();
			
			int newPosition = position;

			maskedTextBox.InvokeSync (delegate {

				System.ComponentModel.MaskedTextProvider prov
					= maskedTextBox.MaskedTextProvider;
	
				string text = prov.ToDisplayString ();
	
				int offset = newPosition;
				for (int i = 0; i < str.Length; i++) {
					int localOffset = offset;
					
					// skip over an unavailable slot if we see one
					bool reachedBounds = false;
					while (!prov.IsEditPosition (i + localOffset)) {
						localOffset++;
						if (i + localOffset >= prov.Length) {
							reachedBounds = true;
							break;
						}
					}
	
					if (reachedBounds)
						break;
	
					// There is already a character here, so while
					// the GUI will actually move this character
					// over, we cannot as there are _many, many_
					// edge cases that we cannot handle.
					// Instead, we skip over the character.
					if (!prov.IsAvailablePosition (i + localOffset)) {
						// Make sure offset is correct for the
						// next iteration
						offset = localOffset;
						continue;
					}
	
					// The correct value of position is equal to
					// the localOffset of the first character.
					//
					// This check needs to be done after
					// IsAvailablePosition in case we are trying to
					// insert into a place that already has a
					// character.
					if (offset != localOffset && i == 0)
						newPosition = localOffset;
					
					// Make sure offset is correct for the
					// next iteration
					offset = localOffset;
	
					text = text.Substring (0, i + offset)
						+ str[i] + text.Substring (i + offset + 1);
				}

				maskedTextBox.Text = text;
			});
			
			position = newPosition;
				// IsAvailablePosition in case we are trying to
				// insert into a place that already has a
				// character.
				if (offset != localOffset && i == 0)
					position = localOffset;
				
				offset = localOffset;

				text = text.Substring (0, i + offset)
					+ str[i] + text.Substring (i + offset + 1);
			}

			maskedTextBox.Text = text;
		}

		public void DeleteText (int start, int end)
		{
			if (maskedTextBox.InvokeSync (m => m.ReadOnly))
				throw new ElementNotEnabledException ();

			maskedTextBox.InvokeSync (delegate {
				// MaskedTextProvider.RemoveAt does not work for this.
				System.ComponentModel.MaskedTextProvider prov
					= maskedTextBox.MaskedTextProvider;
	
				string text = prov.ToDisplayString ();
				for (int i = start; i < end; i++) {
					if (!prov.IsEditPosition (i)
					    || prov.IsAvailablePosition (i))
						continue;
	
					text = text.Substring (0, i) + prov.PromptChar
						+ text.Substring (i + 1);
				}
					continue;

				text = text.Substring (0, i) + prov.PromptChar
					+ text.Substring (i + 1);
			}

				maskedTextBox.Text = text;
			});
		}
#endregion

#region Private Delegates
		private delegate void InsertTextDelegate (string str, ref int position);
		private delegate void DeleteTextDelegate (int start, int end);
#endregion

#region Private Fields
		private SWF.MaskedTextBox maskedTextBox;
#endregion




		
		public void Invoke ()
		{
			if (Provider.Control.InvokeSync (c => !c.Enabled))
				throw new ElementNotEnabledException ();

			SWF.MonthCalendar calendar
				= (SWF.MonthCalendar) provider.DataGridProvider.Control;

			calendar.InvokeSync (delegate {
				int offset = 1;
				if (provider.Direction
					== MonthCalendarButtonProvider.ButtonDirection.Back) {
					offset = -1;
				}
	
				calendar.CurrentMonth = calendar.CurrentMonth.AddMonths (offset);
			});
		}
		
#endregion	




		#region IEditableRange Members
		public void BeginEdit (string text)
		{
			if (numericUpDown.InvokeSync (n => numericUpDown.ReadOnly))
				throw new ElementNotEnabledException ();

			numericUpDown.InvokeSync (delegate {
				numericUpDown.txtView.Text = text;
			});
			}
			numericUpDown.txtView.Text = text;
		}

		public void CommitEdit ()
		{
			numericUpDown.InvokeSync (delegate {
				decimal value = decimal.Parse (numericUpDown.Text);
				if (value < numericUpDown.Minimum)
					value = numericUpDown.Minimum;
				if (value > numericUpDown.Maximum)
					value = numericUpDown.Maximum;
				numericUpDown.Value = value;
			});
				value = numericUpDown.Maximum;
			numericUpDown.Value = value;
		}
		#endregion


		private SWF.NumericUpDown numericUpDown;
		
		#endregion
	}		

	delegate void NumericUpDownBeginEditDelegate (string value);
	delegate void NumericUpDownCommitEditDelegate ();		
}




		#region IRangeValueProvider Members
	
		public bool IsReadOnly {
			get { return numericUpDown.InvokeSync (c => c.ReadOnly); }
		}
		
		public double Minimum {
			get { return numericUpDown.InvokeSync (c => (double) c.Minimum); }
		}
		
		public double Maximum {
			get { return numericUpDown.InvokeSync (c => (double) c.Maximum); }
		}
		
		public double LargeChange {
			get { return double.NaN; }
		}
		public double SmallChange {
			get { return numericUpDown.InvokeSync (c => (double) c.Increment); }
		}

		public double Value {
			get { return numericUpDown.InvokeSync (c => (double) c.Value); }
		}
		
		public void SetValue (double value)

			if (value < Minimum || value > Maximum)
				throw new ArgumentOutOfRangeException ();

			numericUpDown.InvokeSync (delegate { numericUpDown.Value = (decimal) value; });
		}

		#endregion
		

		#region Private Methods
		
		private void PerformSetValue (decimal value) 
		{
			if (numericUpDown.InvokeRequired == true) {
				numericUpDown.BeginInvoke (new NumericUpDownSetValueDelegate (PerformSetValue),
				                           new object [] { value });
				return;
			}
			numericUpDown.Value = value;
		}
			
		#endregion

		
		#endregion
	}
	
	delegate void NumericUpDownSetValueDelegate (decimal value);
}




#region IEmbeddedImageProvider Interface
		public Rect Bounds {
			get {
				return control.InvokeSync (c => {
						if (c.Image == null)
							return Rect.Empty;
				RectangleF rectF = control.Image.GetBounds (ref unit);
				if (unit != GraphicsUnit.Pixel)
					return Rect.Empty;

						GraphicsUnit unit = GraphicsUnit.Pixel;
						RectangleF rectF = c.Image.GetBounds (ref unit);

						if (unit != GraphicsUnit.Pixel)
							return Rect.Empty;

						System.Windows.Rect ret
							= (System.Windows.Rect) Provider.GetPropertyValue (
								AutomationElementIdentifiers.BoundingRectangleProperty.Id);
						ret.X += rectF.X;
						ret.Y += rectF.Y;
						ret.Width = rectF.Width;
						ret.Height = rectF.Height;
						return ret;
					}
				);
			}
		}





		
		public virtual void Invoke ()
		{
			if (Provider.Control.InvokeSync (c => !c.Enabled))
				throw new ElementNotEnabledException ();

			Provider.Control.InvokeSync (delegate { button.PerformClick (); });
		}
	
		#endregion	
		
		#region Private Methods
		
		private void PerformClick ()
		{
			if (Provider.Control.InvokeRequired == true) {
				Provider.Control.BeginInvoke (new SWF.MethodInvoker (PerformClick));
				return;
			}
			button.PerformClick ();
		}
		
		#endregion
		
	}

}




		#region IRangeValueProvider Members
		
		public double Value {
			get { return progressBar.InvokeSync (p => p.Value); }
		}
		
		public bool IsReadOnly {

			if (value < Minimum || value > Maximum)
				throw new ArgumentOutOfRangeException ();
			
			progressBar.InvokeSync (delegate {
				progressBar.Value = (int) value;
			});
				return;
			}
			
			progressBar.Value = (int) value;
		}
		
		#endregion




			if (IsReadOnly)
				throw new ElementNotEnabledException ();

			provider.ListItemProvider.Value = value;
		}

		public bool IsReadOnly {

		}
#endregion

#region Private Fields
		private void PerformSetValue (string value)
		{
			if (provider.ListItemProvider.PropertyGridView.InvokeRequired) {
				provider.ListItemProvider.PropertyGridView.BeginInvoke (
					new SetValueDelegate (PerformSetValue),
					new object [] { value });
				return;
			}

			provider.ListItemProvider.Value = value;
		}

		private PropertyGridListItemValueProvider provider;

		private delegate void SetValueDelegate (string val);
#endregion
	}
}





		public void Select ()
		{
			radioButton.InvokeSync (delegate {
				radioButton.Checked = true;
			});
		}

		public IRawElementProviderSimple SelectionContainer {

		}

#endregion
		
		#region Private Methods
		
		private void PerformSelectDelegate (SWF.RadioButton radioButton)
		{
			if (radioButton.InvokeRequired == true) {
				radioButton.BeginInvoke (new PerformSelectDelegate (PerformSelectDelegate),
				                         new object [] { radioButton });
				return;
			}
			radioButton.Checked = true;
		}
		
		#endregion 
	}
	
	delegate void PerformSelectDelegate (SWF.RadioButton radioButton);
}




		
		public void Invoke ()
		{
			if (!Provider.Control.InvokeSync (c => c.Enabled))
				throw new ElementNotEnabledException ();

			string methodName = string.Empty;

			                                                          | BindingFlags.NonPublic
			                                                          | BindingFlags.Instance);
			if (methodInfo != null) {
				Action<SWF.ScrollBar> invokeMethod
					= (Action<SWF.ScrollBar>) Delegate.CreateDelegate (typeof (Action<SWF.ScrollBar>), 
					                                                   methodInfo);
				provider.ScrollBarContainer.InvokeSync (delegate {
					invokeMethod (provider.ScrollBarContainer);
				});
			}
		}
		
		#endregion	
		
		#region Private Methods
		
		private void PerformScrollBarButtonClick ()
		{
	        if (provider.ScrollBarContainer.InvokeRequired == true) {
	            provider.ScrollBarContainer.BeginInvoke (new SWF.MethodInvoker (PerformScrollBarButtonClick));
	            return;
	        }
			
			invokeMethod (provider.ScrollBarContainer);
			invokeMethod = null;
		}
		
		#endregion
		
		#region Private Fields
		
		private Action<SWF.ScrollBar> invokeMethod;
		private ScrollBarProvider.ScrollBarButtonProvider provider;

		#endregion




			if (value < Minimum || value > Maximum)
				throw new ArgumentOutOfRangeException ();
			
			scrollbar.InvokeSync (delegate {
				scrollbar.Value = (int) value;
			});
		}
		
		public bool IsReadOnly {
			get {
				return scrollbar.InvokeSync (s => !s.Enabled || !s.Visible);
			}
		}
		
		public double LargeChange {
			get { return scrollbar.InvokeSync (s => s.LargeChange); }
		}
		
		public double Maximum {
			get { return scrollbar.InvokeSync (s => s.Maximum); }
		}
		
		public double Minimum {
			get { return scrollbar.InvokeSync (s => s.Minimum); }
		}
		
		public double SmallChange {
			get { return scrollbar.InvokeSync (s => s.SmallChange); }
		}
		
		public double Value {
			get { return scrollbar.InvokeSync (s => s.Value); }
		}
		
		#endregion 
		
		#region Private Methods
		
		private void PerformSetValue (int value)
		{
			if (scrollbar.InvokeRequired == true) {
				scrollbar.BeginInvoke (new PerformSetValueDelegate (PerformSetValue),
				                       new object [] { value });
				return;
			}
			scrollbar.Value = value;
		}
		
		#endregion

		#region Private Fields



		#endregion
	}
	
	delegate void PerformSetValueDelegate (int value);
}




		#region IDockProvider Members
		
		public DockPosition DockPosition {
			get { return splitContainer.InvokeSync (s => Helper.GetDockPosition (s.Dock)); }
		}
		
		public void SetDockPosition (DockPosition dockPosition)
		{
			//throw new InvalidOperationException ();
			
			splitContainer.InvokeSync (delegate {
				splitContainer.Dock = Helper.GetDockStyle (dockPosition);
			});
				return;
			}
			
			splitContainer.Dock = Helper.GetDockStyle (dockPosition);
		}
		
		#endregion

		
		#endregion
	}
	
	delegate void PerformSetDockPositionDelegate (DockPosition dockPosition);
}

Lines 92-102 namespace Mono.UIAutomation.Winforms.Behaviors.SplitContainer Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/SplitContainer/RangeValueProviderBehavior.cs (-21 / +7 lines)
92	if (value < Minimum \|\| value > Maximum)	92	if (value < Minimum \|\| value > Maximum)
93	throw new ArgumentOutOfRangeException ();	93	throw new ArgumentOutOfRangeException ();
94		94
95	PerformSetValue ((int) value);	95	splitcontainer.InvokeSync (delegate {
		96	splitcontainer.SplitterDistance = (int) value;
		97	});
96	}	98	}
97		99
98	public bool IsReadOnly {	100	public bool IsReadOnly {
99	get { return splitcontainer.Enabled == false \|\| splitcontainer.Visible == false; }	101	get { return splitcontainer.InvokeSync (s => !s.Enabled \|\| !s.Visible); }
100	}	102	}
101		103
102	public double LargeChange {	104	public double LargeChange {
Lines 104-114 namespace Mono.UIAutomation.Winforms.Behaviors.SplitContainer Link Here
104	}	106	}
105		107
106	public double Maximum {	108	public double Maximum {
107	get { return splitcontainer.Width - (splitcontainer.SplitterWidth + splitcontainer.Panel2MinSize); }	109	get { return splitcontainer.InvokeSync (s => s.Width - (s.SplitterWidth + s.Panel2MinSize)); }
108	}	110	}
109		111
110	public double Minimum {	112	public double Minimum {
111	get { return splitcontainer.Panel1MinSize; }	113	get { return splitcontainer.InvokeSync (s => s.Panel1MinSize); }
112	}	114	}
113		115
114	public double SmallChange {	116	public double SmallChange {
Lines 116-139 namespace Mono.UIAutomation.Winforms.Behaviors.SplitContainer Link Here
116	}	118	}
117		119
118	public double Value {	120	public double Value {
119	get { return splitcontainer.SplitterDistance; }	121	get { return splitcontainer.InvokeSync (s => s.SplitterDistance); }
120	}	122	}
121		123
122	#endregion	124	#endregion
123
124	#region Private Methods
125
126	private void PerformSetValue (int value)
127	{
128	if (splitcontainer.InvokeRequired == true) {
129	splitcontainer.BeginInvoke (new PerformSetValueDelegate (PerformSetValue),
130	new object [] { value });
131	return;
132	}
133	splitcontainer.SplitterDistance = value;
134	}
135
136	#endregion
137		125
138	#region Private Fields	126	#region Private Fields
139		127
Lines 141-146 namespace Mono.UIAutomation.Winforms.Behaviors.SplitContainer Link Here
141		129
142	#endregion	130	#endregion
143	}	131	}
144
145	delegate void PerformSetValueDelegate (int value);
146	}	132	}




		}
		
		public bool CanResize {
			get { return splitContainer.InvokeSync (s => !(s.Panel1Collapsed || s.Panel2Collapsed)); }
				if (splitContainer.Panel1Collapsed || splitContainer.Panel2Collapsed)
					return false;
				else
					return true;
			}
		}
		
		public bool CanRotate {

		{
			if (!CanResize)
				throw new InvalidOperationException ();

			splitContainer.InvokeSync (delegate {
				if (splitContainer.Orientation == SWF.Orientation.Horizontal)
					splitContainer.Panel1.Width = (int) width;
				else
					splitContainer.Panel1.Width = (int) height;
			});
			if (splitContainer.Orientation == SWF.Orientation.Horizontal)
				splitContainer.Panel1.Width = (int) width;
			else
				splitContainer.Panel1.Width = (int) height;
		}
		
		public void Rotate (double degrees)

		
		#endregion
	}
	
	delegate void PerformResizeDelegate (double width, double height);
}




		#region IDockProvider Members
		
		public DockPosition DockPosition {
			get { return splitter.InvokeSync (s => Helper.GetDockPosition (s.Dock)); }
		}
		
		public void SetDockPosition (DockPosition dockPosition)

			    dockPosition == DockPosition.None)
				throw new InvalidOperationException ();
			
			splitter.InvokeSync (delegate {
				splitter.Dock = Helper.GetDockStyle (dockPosition);
			});
				return;
			}
			
			splitter.Dock = Helper.GetDockStyle (dockPosition);
		}
		
		#endregion

		
		#endregion
	}
	
	delegate void PerformSetDockPositionDelegate (DockPosition dockPosition);
}

Lines 92-102 namespace Mono.UIAutomation.Winforms.Behaviors.Splitter Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/Splitter/RangeValueProviderBehavior.cs (-21 / +7 lines)
92	if (value < Minimum \|\| value > Maximum)	92	if (value < Minimum \|\| value > Maximum)
93	throw new ArgumentOutOfRangeException ();	93	throw new ArgumentOutOfRangeException ();
94		94
95	PerformSetValue ((int) value);	95	splitter.InvokeSync (delegate {
		96	splitter.SplitPosition = (int) value;
		97	});
96	}	98	}
97		99
98	public bool IsReadOnly {	100	public bool IsReadOnly {
99	get { return splitter.Enabled == false \|\| splitter.Visible == false; }	101	get { return splitter.InvokeSync (s => !s.Enabled \|\| !s.Visible); }
100	}	102	}
101		103
102	public double LargeChange {	104	public double LargeChange {
Lines 104-114 namespace Mono.UIAutomation.Winforms.Behaviors.Splitter Link Here
104	}	106	}
105		107
106	public double Maximum {	108	public double Maximum {
107	get { return splitter.MaxSize; }	109	get { return splitter.InvokeSync (s => s.MaxSize); }
108	}	110	}
109		111
110	public double Minimum {	112	public double Minimum {
111	get { return splitter.MinSize; }	113	get { return splitter.InvokeSync (s => s.MinSize); }
112	}	114	}
113		115
114	public double SmallChange {	116	public double SmallChange {
Lines 116-146 namespace Mono.UIAutomation.Winforms.Behaviors.Splitter Link Here
116	}	118	}
117		119
118	public double Value {	120	public double Value {
119	get { return splitter.SplitPosition; }	121	get { return splitter.InvokeSync (s => s.SplitPosition); }
120	}	122	}
121		123
122	#endregion	124	#endregion
123		125
124	#region Private Methods
125
126	private void PerformSetValue (int value)
127	{
128	if (splitter.InvokeRequired == true) {
129	splitter.BeginInvoke (new PerformSetValueDelegate (PerformSetValue),
130	new object [] { value });
131	return;
132	}
133	splitter.SplitPosition = value;
134	}
135
136	#endregion
137
138	#region Private Fields	126	#region Private Fields
139		127
140	private SWF.Splitter splitter;	128	private SWF.Splitter splitter;
141		129
142	#endregion	130	#endregion
143	}	131	}
144
145	delegate void PerformSetValueDelegate (int value);
146	}	132	}




		
		public void Move (double x, double y)
		{
			splitter.InvokeSync (delegate {
				if (splitter.Dock == SWF.DockStyle.Left || splitter.Dock == SWF.DockStyle.Right)
					splitter.SplitPosition = (int) x;
				else
					splitter.SplitPosition = (int) y;
			});
			if (splitter.Dock == SWF.DockStyle.Left || splitter.Dock == SWF.DockStyle.Right)
				splitter.SplitPosition = (int) x;
			else
				splitter.SplitPosition = (int) y;
		}
		
		public void Resize (double width, double height)

Lines 86-92 namespace Mono.UIAutomation.Winforms.Behaviors.StatusBar Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/StatusBar/GridProviderBehavior.cs (-1 / +1 lines)
86	}	86	}
87		87
88	public int ColumnCount {	88	public int ColumnCount {
89	get { return statusBar.Panels.Count; }	89	get { return statusBar.InvokeSync (s => s.Panels.Count); }
90	}	90	}
91		91
92	public IRawElementProviderSimple GetItem (int row, int column)	92	public IRawElementProviderSimple GetItem (int row, int column)

Lines 100-106 namespace Mono.UIAutomation.Winforms.Behaviors.StatusBar Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/StatusBar/StatusBarPanelGridItemProviderBehavior.cs (-1 / +3 lines)
100	}	100	}
101		101
102	public int Column {	102	public int Column {
103	get { return statusBarPanel.Parent.Panels.IndexOf (statusBarPanel); }	103	get {
		104	return statusBarPanel.Parent.InvokeSync (s => s.Panels.IndexOf (statusBarPanel));
		105	}
104	}	106	}
105		107
106	public int RowSpan {	108	public int RowSpan {

Lines 86-92 namespace Mono.UIAutomation.Winforms.Behaviors.StatusStrip Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/StatusStrip/GridProviderBehavior.cs (-1 / +1 lines)
86	}	86	}
87		87
88	public int ColumnCount {	88	public int ColumnCount {
89	get { return statusStrip.Items.Count; }	89	get { return statusStrip.InvokeSync (s => s.Items.Count); }
90	}	90	}
91		91
92	public IRawElementProviderSimple GetItem (int row, int column)	92	public IRawElementProviderSimple GetItem (int row, int column)





		public double HorizontalScrollPercent {
			get {
				return tabControl.InvokeSync (t => {
					if (!t.ShowSlider)
						return ScrollPatternIdentifiers.NoScroll;
					else
						return (double) (100 / t.TabCount);
				});
			}
		}

		public double HorizontalViewSize {
			get {
				return tabControl.InvokeSync (t => {
					if (!t.ShowSlider)
						return 100;
					else {
						// FIXME: remove this when we can depend on MWF > 2.4
						try {
							return Helper.GetPrivateProperty<SWF.TabControl, double> (t, "UIAHorizontalViewSize");
						} catch (NotSupportedException) { }
						try {
							int leftArea =
								Helper.GetPrivateProperty<SWF.TabControl, int> (t, "LeftScrollButtonArea.Left");
							return (double) leftArea * 100 / t.TabPages [t.TabCount - 1].TabBounds.Right;
						} catch (NotSupportedException) { }
						return Double.NaN;

//						return tabControl.UIAHorizontalViewSize;
					}
				});
			}
		}


		}

		public bool HorizontallyScrollable {
			get { return tabControl.InvokeSync (t => t.ShowSlider); }
		}

		public bool VerticallyScrollable {

			    horizontalAmount == ScrollAmount.SmallIncrement)
				throw new ArgumentException ();

/* TODO:
			Helper.SynchronizedSet (tabControl, delegate {
				if (horizontalAmount == ScrollAmount.SmallIncrement)
					tabControl.SliderPos += 1;
				else if (horizontalAmount == ScrollAmount.SmallDecrement)
					tabControl.SliderPos -= 1;
				else
					return;
			});
*/
		}

		public void SetScrollPercent (double horizontalPercent, double verticalPercent)

Lines 111-123 namespace Mono.UIAutomation.Winforms.Behaviors.TabPage Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/TabPage/SelectionItemProviderBehavior.cs (-6 / +3 lines)
111	if (IsSelected) {	111	if (IsSelected) {
112	return;	112	return;
113	}	113	}
114
115	if (pageProvider.TabControlProvider.Control.InvokeRequired) {
116	pageProvider.TabControlProvider.Control.BeginInvoke (new MethodInvoker (Select));
117	return;
118	}
119		114
120	pageProvider.TabControlProvider.SelectItem (pageProvider);	115	pageProvider.TabControlProvider.Control.InvokeSync (delegate {
		116	pageProvider.TabControlProvider.SelectItem (pageProvider);
		117	});
121	}	118	}
122		119
123	public bool IsSelected {	120	public bool IsSelected {




			get {
				// TODO: This won't scale; we really should
				// find a better way of doing it
				return Provider.Control.InvokeSync (c => {
						SWF.Document document = Document;
						if (document.caret.line.line_no > document.Lines)
							return Text.Length;
						return Document.LineTagToCharIndex
							(document.caret.line, document.CaretPosition);
					}
				);
			}
		}

		public bool SetCaretOffset (int offset)
		{
			return Provider.Control.InvokeSync (c => {
				if (offset < 0)
					return false;
				SWF.Document document = Document;
				int curPos = 0;
				SWF.Line line = null;
				for (int i = 1;i <= document.Lines;i++) {
					line = document.GetLine (i);
					int length = line.Text.ToString().Length;
					if (curPos + length >= offset) {
						document.PositionCaret (line, offset - curPos);
						return true;
					}
					curPos += length;
				}
				return false;
			});
			return false;
		}

		public string GetSelection (int selectionNum, out int startOffset, out int endOffset)

				return null;
			SWF.TextBoxBase textBoxBase = TextBoxBase;
			if (TextBoxBase.Document.SelectionVisible) {
				int sel_start = textBoxBase.InvokeSync (t => t.SelectionStart);
				int sel_len = textBoxBase.InvokeSync (t => t.SelectionLength);
				string text = Text;

				startOffset = sel_start;
				endOffset = startOffset + sel_len;
				return text.Substring (startOffset, endOffset - startOffset);
			}
			return null;
		}

				if (Provider.Control is SWF.TextBoxBase)
					return (SWF.TextBoxBase)Provider.Control;
				else if (Provider.Control is SWF.UpDownBase)
					return ((SWF.UpDownBase)Provider.Control).InvokeSync (c => c.txtView);
				else
					throw new Exception ("TextBoxBase: Unknown type: " + Provider.Control);
			}


		private string Text {
			get {
				if (TextBoxBase is SWF.MaskedTextBox) {
					return ((SWF.MaskedTextBox) TextBoxBase).InvokeSync (t => t.MaskedTextProvider.ToDisplayString ());
				} else {
					return TextBoxBase.InvokeSync (t => t.Text);
				}
			}
			set {
				SWF.TextBoxBase textBoxBase = TextBoxBase;
				textBoxBase.InvokeSync (delegate { textBoxBase.Text = value; });
			}
			set { TextBoxBase.Text = value; }
		}

		#endregion





		public void Copy (int start, int end)
		{
			TextBoxBase.InvokeSync (delegate {
				string text = Text;
				start = (int) System.Math.Max (start, 0);
				end = (int) System.Math.Min (end, text.Length);
				SWF.Clipboard.SetText (text.Substring (start, end - start));
			});
		}
		
		public void Paste (int position)
		{
			TextBoxBase.InvokeSync (delegate {
				string text = Text;
				position = (int) System.Math.Max (position, 0);
				position = (int) System.Math.Min (position, text.Length);

				// If you were to paste using the GUI, it would only
				// paste enough until the control was full, so emulate
				// that behavior.
				int maxLength = 0;
				if (Provider is TextBoxProvider)
					maxLength = ((TextBoxProvider) Provider).MaxLength;

				string clipboardText = SWF.Clipboard.GetText ();
				if (maxLength > 0 && clipboardText.Length > (maxLength - position))
					clipboardText = clipboardText.Substring (0, maxLength - position);

				IInsertDeleteTextProvider insertDeleteProv
					= Provider.GetPatternProvider (InsertDeleteTextPatternIdentifiers.Pattern.Id)
						as IInsertDeleteTextProvider;
				if (insertDeleteProv != null)
					insertDeleteProv.InsertText (clipboardText, ref position);
				else
					TextBoxBase.Text = text.Insert (position, clipboardText);
			});
		}

		#endregion

				if (Provider.Control is SWF.TextBoxBase)
					return (SWF.TextBoxBase)Provider.Control;
				else if (Provider.Control is SWF.UpDownBase)
					return ((SWF.UpDownBase)Provider.Control).InvokeSync (c => c.txtView);
				else
					throw new Exception ("TextBoxBase: Unknown type: " + Provider.Control);
			}

		private string Text {
			get {
				if (TextBoxBase is SWF.MaskedTextBox)
					return ((SWF.MaskedTextBox) TextBoxBase).InvokeSync (c => c.MaskedTextProvider.ToDisplayString ());
				else
					return TextBoxBase.InvokeSync (c => c.Text);
			}
			set {
				SWF.TextBoxBase textBoxBase = TextBoxBase;
				textBoxBase.InvokeSync (delegate { textBoxBase.Text = value; }); 
			}
			set { TextBoxBase.Text = value; }
		}

	}




			if (propertyId == AutomationElementIdentifiers.IsPasswordProperty.Id) {
				if (Provider.Control is SWF.TextBox) {
					SWF.TextBox textbox = TextBox;
					return textbox.InvokeSync (c => c.UseSystemPasswordChar || (int) c.PasswordChar != 0);
				} else if (Provider.Control is SWF.RichTextBox) {
					return false;
				}

				
			//TODO: Return null when system cursor is not present, how to?

			return TextBoxBase.InvokeSync (c => {
				if (!c.Document.SelectionVisible)
					return new ITextRangeProvider [0];
	
				int sel_len = c.SelectionLength;
				int sel_start = c.SelectionStart;
	
				return new ITextRangeProvider [] { 
					new TextRangeProvider (this, TextBoxBase, sel_start, sel_start + sel_len)
				};
			});
		}
		
		public ITextRangeProvider[] GetVisibleRanges ()
		{
			int start_line = -1, end_line = -1;
			System.Drawing.Rectangle bounds = TextBoxBase.InvokeSync (c => c.Bounds);
			Document.GetVisibleLineIndexes (bounds, out start_line, out end_line);

			ITextRangeProvider range = DocumentRange.Clone ();
			range.MoveEndpointByUnit (TextPatternRangeEndpoint.Start, TextUnit.Line, start_line);

				if (Provider.Control is SWF.TextBoxBase)
					return (SWF.TextBoxBase)Provider.Control;
				else if (Provider.Control is SWF.UpDownBase)
					return ((SWF.UpDownBase)Provider.Control).InvokeSync (c => c.txtView);
				else
					throw new Exception ("TextBoxBase: Unknown type: " + Provider.Control);
			}

		}

		private SWF.Document Document { 
			get { return TextBoxBase.InvokeSync (c => c.Document); }
		}


	}
}




		#region IValueProvider: Specialization
		
		public bool IsReadOnly {
			get {
				return ((SWF.TextBoxBase) Provider.Control).InvokeSync (c => c.ReadOnly 
				                                                         || !c.Enabled);
			}
		}
		
		public string Value {
			get {
				if (Provider.Control is SWF.MaskedTextBox) {
					System.ComponentModel.MaskedTextProvider mtp
						= ((SWF.MaskedTextBox) Provider.Control).InvokeSync (c => c.MaskedTextProvider);
					if (mtp != null) {
						return mtp.ToDisplayString ();
					}
				}

				return Provider.Control.InvokeSync (c => c.Text);
			}
		}


			if (IsReadOnly)
				throw new ElementNotEnabledException ();

			Provider.Control.InvokeSync (delegate {
					int maxLength = ((TextBoxProvider) Provider).MaxLength;
					if (maxLength > 0
					    && value.Length > maxLength) {
						value = value.Substring (0, maxLength);
					}
					
					Provider.Control.Text = value;
				}
			);
				Provider.Control.BeginInvoke (new SetValueDelegate (PerformSetValue),
				                              new object [] {value});
				return;
			}

			int maxLength = ((TextBoxProvider) Provider).MaxLength;
			if (maxLength > 0
			    && value.Length > maxLength) {
				value = value.Substring (0, maxLength);
			}
			
			Provider.Control.Text = value;
		}

		private delegate void SetValueDelegate (string val);
		
		#endregion
	}




		
		#region IExpandCollapseProvider Members
		
		public ExpandCollapseState ExpandCollapseState {
		{
			get {
				SWF.Menu menu = toolBarButton.DropDownMenu;
				if (menu == null)
					return ExpandCollapseState.Collapsed;

				return toolBar.InvokeSync (t => toolBarButton.Pushed ? ExpandCollapseState.Expanded
					                                   : ExpandCollapseState.Collapsed
				);
			}
		}



		private void PerformExpandCollapse ()
		{
			toolBar.InvokeSync (delegate {
				SWF.ContextMenu menu = toolBarButton.DropDownMenu as SWF.ContextMenu;
				if (menu == null)
					return;
				menu.Show (toolBar,
					   new Point (toolBarButton.Rectangle.X, toolBar.Height));
			});
				return;
			menu.Show (toolBar,
			           new Point (toolBarButton.Rectangle.X, toolBar.Height));
		}
		
		#endregion




		
		public void Invoke ()
		{
			bool notEnabled = toolBar.InvokeSync (t => !t.Enabled || !toolBarButton.Enabled);
				
			if (notEnabled)
				throw new ElementNotEnabledException ();

			toolBar.InvokeSync (delegate {
				toolBar.UIAPerformClick (toolBarButton);
			});
		}
		
		#endregion

		#region Private Methods

		private void PerformClick ()
		{
			if (toolBar.InvokeRequired == true) {
				toolBar.BeginInvoke (new SWF.MethodInvoker (PerformClick));
				return;
			}

			toolBarButton.Parent.UIAPerformClick (toolBarButton);
		}
		#endregion

		#region Private Fields

		private SWF.ToolBarButton toolBarButton;




		public ToggleState ToggleState
		{
			get {
				if (toolBar.InvokeSync (t => toolBarButton.Pushed))
					return ToggleState.On;
				else
					return ToggleState.Off;

			if (!toolBarButton.Enabled)
				throw new ElementNotEnabledException ();

			toolBar.InvokeSync (delegate {
				toolBar.UIAPerformClick (toolBarButton);
			});
		#endregion

		#region Private Methods

		private void PerformToggle ()
		{
			if (toolBar.InvokeRequired == true) {
				toolBar.BeginInvoke (new SWF.MethodInvoker (PerformToggle));
				return;
			}

			toolBar.UIAPerformClick (toolBarButton);
		}
		
		#endregion




			if (button.Enabled == false)
				throw new ElementNotEnabledException ();

			SWF.ToolStrip toolstrip = ((SWF.ToolStripButton) Provider.Component).Owner;
			toolstrip.InvokeSync (delegate {
				button.PerformClick ();
			});
		{
			SWF.ToolStrip toolstrip = ((SWF.ToolStripButton)Provider.Component).Owner;
			if (toolstrip.InvokeRequired == true) {
				toolstrip.BeginInvoke (new SWF.MethodInvoker (PerformClick));
				return;
			}
			button.PerformClick ();
		}
#endregion	


Lines 74-80 namespace Mono.UIAutomation.Winforms.Behaviors.ToolStripButton Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ToolStripButton/ToggleProviderBehavior.cs (-11 / +16 lines)
74	#region IToggleProvider Members	74	#region IToggleProvider Members
75	public ToggleState ToggleState {	75	public ToggleState ToggleState {
76	get {	76	get {
77	switch (button.CheckState) {	77	SWF.CheckState state =
		78	Owner.InvokeSync (delegate { return button.CheckState; });
		79
		80	switch (state) {
78	case SWF.CheckState.Checked:	81	case SWF.CheckState.Checked:
79	return ToggleState.On;	82	return ToggleState.On;
80	case SWF.CheckState.Unchecked:	83	case SWF.CheckState.Unchecked:
Lines 91-97 namespace Mono.UIAutomation.Winforms.Behaviors.ToolStripButton Link Here
91	if (!button.Enabled)	94	if (!button.Enabled)
92	throw new ElementNotEnabledException ();	95	throw new ElementNotEnabledException ();
93		96
94	switch (button.CheckState) {	97	SWF.CheckState state =
		98	Owner.InvokeSync (delegate { return button.CheckState; });
		99
		100	switch (state) {
95	case SWF.CheckState.Checked:	101	case SWF.CheckState.Checked:
96	PerformToggle (button, SWF.CheckState.Unchecked);	102	PerformToggle (button, SWF.CheckState.Unchecked);
97	break;	103	break;
Lines 109-122 namespace Mono.UIAutomation.Winforms.Behaviors.ToolStripButton Link Here
109	#region Private Methods	115	#region Private Methods
110	private void PerformToggle (SWF.ToolStripButton button, SWF.CheckState state)	116	private void PerformToggle (SWF.ToolStripButton button, SWF.CheckState state)
111	{	117	{
112	SWF.ToolStrip toolstrip = ((SWF.ToolStripButton) Provider.Component).Owner;	118	Owner.InvokeSync (delegate {
113	if (toolstrip.InvokeRequired) {	119	button.CheckState = state;
114	toolstrip.BeginInvoke (new PerformToggleDelegate (PerformToggle),	120	});
115	new object [] { button, state });	121	}
116	return;	122	#endregion
117	}
118		123
119	button.CheckState = state;	124	#region Private Properties
		125	private SWF.ToolStrip Owner {
		126	get { return ((SWF.ToolStripButton) Provider.Component).Owner; }
120	}	127	}
121	#endregion	128	#endregion
122		129
Lines 124-129 namespace Mono.UIAutomation.Winforms.Behaviors.ToolStripButton Link Here
124	private SWF.ToolStripButton button;	131	private SWF.ToolStripButton button;
125	#endregion	132	#endregion
126	}	133	}
127
128	delegate void PerformToggleDelegate (SWF.ToolStripButton button, SWF.CheckState state);
129	}	134	}




		ToolStripItemProvider itemProvider;

		#endregion
		
		#region Constructor
		
		public InvokeProviderBehavior (ToolStripItemProvider provider)

			if (((SWF.ToolStripItem)Provider.Component).Enabled == false)
				throw new ElementNotEnabledException ();

			SynchronizedPerformClick ();
		}
		
		#endregion	
		
		#region Private Methods
		
		private void SynchronizedPerformClick ()
		{
			SWF.ToolStripItem item = (SWF.ToolStripItem) Provider.Component;
			if (item.Owner != null)
				item.Owner.InvokeSync (delegate { 
					PerformClick (item); 
				});
			else // Hopefully we shouldn't have any issue
				PerformClick (item);
		}

		private void PerformClick (SWF.ToolStripItem item)
		{
			SWF.ToolStrip currentParent = item.GetCurrentParent ();

			// Invoking without a visible parent results in exceptions
			if (currentParent == null || !currentParent.Visible)
				return;

			var dropdown = item as SWF.ToolStripDropDownItem;
			bool hide = false;
			if (dropdown != null)
				hide = dropdown.Pressed;

			// Make sure selection changes, or else another item's
			// dropdown menu might still appear.
			if (item.Owner != null)
				item.Select ();
			
			item.PerformClick ();

			// PerformClick does _not_ show/hide the DropDown, so
			// we must do this manually.  On Vista, clicking the
			// button appears to both Show the drop down and
			// Perform a click, so we emulate that behavior.
			if (item is SWF.ToolStripDropDownButton) {
				SWF.ToolStripDropDownButton dropDown = (SWF.ToolStripDropDownButton) item;
				if (!dropDown.Pressed) {
					dropDown.ShowDropDown ();
				} else {
					dropDown.HideDropDown ();
				}
			} else if (item is SWF.ToolStripMenuItem) {
				SWF.ToolStripMenuItem menuItem = (SWF.ToolStripMenuItem) item;
				if (!menuItem.Pressed) {
					menuItem.ShowDropDown ();
				} else {
					menuItem.HideDropDown ();
				}
			}

			item.PerformClick ();
		}
		
		#endregion




				if (dropdown == null)
					return ExpandCollapseState.Collapsed;

				return Owner.InvokeSync (o => dropdown.Visible ? ExpandCollapseState.Expanded
				                                     : ExpandCollapseState.Collapsed
				);
			}
		}

		public void Collapse ()
		{
			Owner.InvokeSync (delegate {
				((SWF.ToolStripSplitButton) Provider.Component).HideDropDown ();
			});
		}

		public void Expand ()
		{
			Owner.InvokeSync (delegate {
				((SWF.ToolStripSplitButton) Provider.Component).ShowDropDown ();
			});
		}
#endregion

#region Private Properties
		private SWF.ToolStrip Owner {
			get { return ((SWF.ToolStripItem) Provider.Component).Owner; }
		}
#endregion
	}




		
		public void Invoke ()
		{
			if (Provider.Control.InvokeSync (c => !c.Enabled))
				throw new ElementNotEnabledException ();

			Provider.Control.InvokeSync (delegate {
				if (provider.Orientation == TrackBarProvider.TrackBarButtonOrientation.LargeBack)
					((SWF.TrackBar)Provider.Control).LargeDecrement ();
				else if (provider.Orientation == TrackBarProvider.TrackBarButtonOrientation.LargeForward)
					((SWF.TrackBar)Provider.Control).LargeIncrement ();
			});
				((SWF.TrackBar)Provider.Control).LargeDecrement ();
			else if (provider.Orientation == TrackBarProvider.TrackBarButtonOrientation.LargeForward)
				((SWF.TrackBar)Provider.Control).LargeIncrement ();
		}
		
		#endregion	




			if (value < Minimum || value > Maximum)
				throw new ArgumentOutOfRangeException ();
			
			trackbar.InvokeSync (delegate {
				trackbar.Value = (int) value;
			});
		}
		
		public bool IsReadOnly {
			get { return trackbar.InvokeSync (t => !t.Enabled || !t.Visible); }
		}
		
		public double LargeChange {
			get { return trackbar.InvokeSync (t => t.LargeChange); }
		}
		
		public double Maximum {
			get { return trackbar.InvokeSync (t => t.Maximum); }
		}
		
		public double Minimum {
			get { return trackbar.InvokeSync (t => t.Minimum); }
		}
		
		public double SmallChange {
			get { return trackbar.InvokeSync (t => t.SmallChange); }
		}
		
		public double Value {
			get { return trackbar.InvokeSync (t => t.Value); }
		}
		
		#endregion 
		
		#region Private Methods
		
		private void PerformSetValue (int value)
		{
			if (trackbar.InvokeRequired == true) {
				trackbar.BeginInvoke (new PerformSetValueDelegate (PerformSetValue),
				                       new object [] { value });
				return;
			}
			trackbar.Value = value;
		}
		
		#endregion

		#region Private Fields



		#endregion
	}
	
	delegate void PerformSetValueDelegate (int value);
}




			if (!treeView.Enabled)
				throw new ElementNotEnabledException ();
			
			treeView.InvokeSync (delegate {
				nodeProvider.TreeNode.Collapse ();
			});
			}

			PerformCollapse ();
		}
		
		public void Expand ()


			if (!treeView.Enabled)
				throw new ElementNotEnabledException ();
			
			if (treeView != null && treeView.InvokeRequired) {
				treeView.BeginInvoke (new SWF.MethodInvoker (PerformExpand));
				return;
			}

			treeView.InvokeSync (delegate {
				nodeProvider.TreeNode.Expand ();
			});
		}
		
		public ExpandCollapseState ExpandCollapseState {

		}
		
		#endregion

		#region Private Methods

		private void PerformCollapse ()
		{
			nodeProvider.TreeNode.Collapse ();
		}

		private void PerformExpand ()
		{
			nodeProvider.TreeNode.Expand ();
		}

		#endregion
	}
}




				Log.Error ("TreeView.ScrollItem.ScrollIntoView: Parent TreeView is not set");
				return;
			}
			if (treeView.InvokeRequired)
				treeView.BeginInvoke (new SWF.MethodInvoker (ScrollIntoView));

			treeView.InvokeSync (delegate {
				nodeProvider.TreeNode.EnsureVisible ();
			});
		}

		#endregion




				Log.Error ("TreeView.SelectionItem.Select: Parent TreeView is not set");
				return;
			}

			if (!treeView.Enabled)
				throw new ElementNotEnabledException ();

			treeView.InvokeSync (delegate {
				treeView.SelectedNode = nodeProvider.TreeNode;
			});
			treeView.SelectedNode = nodeProvider.TreeNode;
		}
		
		public bool IsSelected {
			get {
				return nodeProvider.TreeNode.TreeView.InvokeSync (
					t => nodeProvider.TreeNode.IsSelected
				);
			}
		}
		




		
		public IRawElementProviderSimple [] GetSelection ()
		{
			SWF.TreeNode selectedNode = treeView.InvokeSync (c => c.SelectedNode);
			TreeNodeProvider selectedNodeProvider = null;
			
			if (selectedNode != null)

		}
		
		public bool CanSelectMultiple {
			get { return false; }
				return false;
			}
		}
		
		public bool IsSelectionRequired {
			get {
				return treeView.InvokeSync (t => t.SelectedNode != null);
			}
		}
		




				Log.Error ("TreeView.Toggle.Invoke: Parent TreeView is not set");
				return;
			}

			if (!treeView.Enabled)
				throw new ElementNotEnabledException ();
			if (treeView.InvokeRequired)
				treeView.BeginInvoke (new SWF.MethodInvoker (Toggle));
			
			treeView.InvokeSync (delegate {
				nodeProvider.TreeNode.Checked = !nodeProvider.TreeNode.Checked;
			});
		}
		
		public ToggleState ToggleState {




				Log.Error ("TreeView.Value.SetValue: Parent TreeView is not set");
				return;
			}

			if (!treeView.Enabled)
				throw new ElementNotEnabledException ();

			treeView.InvokeSync (delegate {
				nodeProvider.TreeNode.Text = val;
			});
			}
			PerformSetValue (val);
		}
		
		public bool IsReadOnly {
			get { return false; }
				return false;
			}
		}
		
		public string Value {
			get {
				return nodeProvider.TreeNode.TreeView.InvokeSync (
					t => nodeProvider.TreeNode.Text
				);
			}
		}
		
		#endregion

		#region Private Methods

		private void PerformSetValue (string val)
		{
			nodeProvider.TreeNode.Text = val;
		}

		private delegate void SetValueDelegate (string val);

		#endregion
	}
}




		
		public void Invoke ()
		{
			provider.UpDownBase.InvokeSync (delegate {
				if (provider.Orientation == UpDownBaseProvider.UpDownBaseButtonOrientation.Forward)
					provider.UpDownBase.UpButton ();
				else if (provider.Orientation == UpDownBaseProvider.UpDownBaseButtonOrientation.Backward)
					provider.UpDownBase.DownButton ();
			});
		}

		private void PerformInvoke ()
		{
			if (provider.Orientation == UpDownBaseProvider.UpDownBaseButtonOrientation.Forward)
				provider.UpDownBase.UpButton ();
			else if (provider.Orientation == UpDownBaseProvider.UpDownBaseButtonOrientation.Backward)
				provider.UpDownBase.DownButton ();
		}
		
		#endregion

		
		#endregion
	}
}




		#region IValueProvider Members
		
		public bool IsReadOnly {
			get { return upDownBase.InvokeSync (c => c.ReadOnly); }
		}
		
		public string Value {
			get { return upDownBase.InvokeSync (c => c.Text); }
		}
		
		public void SetValue (string value)
		{
			if (upDownBase.InvokeSync (c => !c.Enabled || c.ReadOnly))
				throw new ElementNotEnabledException ();

			upDownBase.InvokeSync (delegate { upDownBase.Text = value; });
		}
		
		#endregion
		
		#region Private Methods
		
		private void PerformSetValue (string value) 
		{
			if (upDownBase.InvokeRequired == true) {
				upDownBase.BeginInvoke (new UpDownBaseSetValueDelegate (PerformSetValue),
				                          new object [] { value } );
				return;
			}
			
			upDownBase.Text = value;
		}
		
		#endregion

		
		#endregion
	}
	
	delegate void UpDownBaseSetValueDelegate (string value);
}




		
		public override void Connect ()
		{
			Provider.Control.InvokeSync (delegate {
				Provider.Control.Resize += new EventHandler (OnIsOffScreen);
				Provider.Control.LocationChanged += new EventHandler (OnIsOffScreen);
				if (Provider.Control.Parent != null)
					Provider.Control.Parent.LocationChanged += new EventHandler (OnIsOffScreen);
				if (Provider.Control.FindForm () != null)
				Provider.Control.FindForm ().Resize += new EventHandler (OnIsOffScreen);
			});
		}

		public override void Disconnect ()
		{
			Provider.Control.InvokeSync (delegate {
				Provider.Control.Resize -= new EventHandler (OnIsOffScreen);
				Provider.Control.LocationChanged -= new EventHandler (OnIsOffScreen);
				if (Provider.Control.Parent != null)
					Provider.Control.Parent.LocationChanged -= new EventHandler (OnIsOffScreen);
				if (Provider.Control.FindForm () != null)
				Provider.Control.FindForm ().Resize -= new EventHandler (OnIsOffScreen);
			});
		}
		
		#endregion

Lines 116-122 namespace Mono.UIAutomation.Winforms.Events Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/AutomationIsPatternAvailablePropertyEvent.cs (-1 lines)
116	return;	116	return;
117		117
118	bool newValue = val ?? false;	118	bool newValue = val ?? false;
119
120	AutomationPropertyChangedEventArgs args	119	AutomationPropertyChangedEventArgs args
121	= new AutomationPropertyChangedEventArgs (property,	120	= new AutomationPropertyChangedEventArgs (property,
122	!newValue,	121	!newValue,

Lines 55-65 namespace Mono.UIAutomation.Winforms.Events Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/BaseAutomationEvent.cs (-5 / +8 lines)
55	protected void RaiseAutomationEvent ()	55	protected void RaiseAutomationEvent ()
56	{	56	{
57	if (AutomationInteropProvider.ClientsAreListening == true) {	57	if (AutomationInteropProvider.ClientsAreListening == true) {
58	AutomationEventArgs args =	58	// Helper.DelegateQueue.Get ().Enqueue (delegate {
59	new AutomationEventArgs (Event);	59	// System.Threading.ThreadPool.QueueUserWorkItem (v => {
60	AutomationInteropProvider.RaiseAutomationEvent (Event,	60	AutomationEventArgs args =
61	Provider,	61	new AutomationEventArgs (Event);
62	args);	62	AutomationInteropProvider.RaiseAutomationEvent (Event,
		63	Provider,
		64	args);
		65	// });
63	}	66	}
64	}	67	}
65		68




		{
			((SWF.ComboBox) Provider.Control).SelectedIndexChanged 
				+= new EventHandler (OnElementSelectedEvent);
			if (Provider.Control is SWF.DirComboBox)
				((SWF.ComboBox) Provider.Control).SelectedValueChanged 
					+= new EventHandler (OnElementSelectedEvent);
		}

		public override void Disconnect ()
		{
			if (Provider.Control is SWF.DirComboBox)
				((SWF.ComboBox) Provider.Control).SelectedValueChanged 
					-= new EventHandler (OnElementSelectedEvent);
			((SWF.ComboBox) Provider.Control).SelectedIndexChanged 
				-= new EventHandler (OnElementSelectedEvent);
		}

		{
			ListItemProvider provider = (ListItemProvider) Provider;
			
			if (provider.Index == ((SWF.ComboBox) provider.Control).InvokeSync (c => c.SelectedIndex))
				RaiseAutomationEvent ();
		}
		




		{
			((SWF.ComboBox) Provider.Control).SelectedIndexChanged 
				+= new EventHandler (OnElementSelectedEvent);
			if (Provider.Control is SWF.DirComboBox)
				((SWF.ComboBox) Provider.Control).SelectedValueChanged 
					+= new EventHandler (OnElementSelectedEvent);
		}

		public override void Disconnect ()
		{
			if (Provider.Control is SWF.DirComboBox)
				((SWF.ComboBox) Provider.Control).SelectedValueChanged 
					-= new EventHandler (OnElementSelectedEvent);
			((SWF.ComboBox) Provider.Control).SelectedIndexChanged 
				-= new EventHandler (OnElementSelectedEvent);
		}




		{
			((SWF.ComboBox) Provider.Control).SelectedIndexChanged 
				+= new EventHandler (OnSelectedIndexChanged);
			if (Provider.Control is SWF.DirComboBox)
				((SWF.ComboBox) Provider.Control).SelectedValueChanged 
					+= new EventHandler (OnSelectedIndexChanged);
		}

		public override void Disconnect ()
		{
			if (Provider.Control is SWF.DirComboBox)
				((SWF.ComboBox) Provider.Control).SelectedValueChanged 
					-= new EventHandler (OnSelectedIndexChanged);
			((SWF.ComboBox) Provider.Control).SelectedIndexChanged 
				-= new EventHandler (OnSelectedIndexChanged);
		}




		{
			((SWF.ComboBox) Provider.Control).SelectedIndexChanged 
				+= new EventHandler (OnSelectedIndexChanged);
			if (Provider.Control is SWF.DirComboBox)
				((SWF.ComboBox) Provider.Control).SelectedValueChanged 
					+= new EventHandler (OnSelectedIndexChanged);
		}

		public override void Disconnect ()
		{
			if (Provider.Control is SWF.DirComboBox)
				((SWF.ComboBox) Provider.Control).SelectedValueChanged 
					-= new EventHandler (OnSelectedIndexChanged);
			((SWF.ComboBox) Provider.Control).SelectedIndexChanged 
				-= new EventHandler (OnSelectedIndexChanged);
		}

Lines 70-81 namespace Mono.UIAutomation.Winforms.Events.DataGrid Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/DataGrid/DataItemAutomationFocusChangedEvent.cs (-6 / +8 lines)
70		70
71	private void OnFocusChangedEvent (object sender, EventArgs args)	71	private void OnFocusChangedEvent (object sender, EventArgs args)
72	{	72	{
73	SWF.DataGridCell currentCell = itemProvider.DataGridProvider.DataGrid.CurrentCell;	73	itemProvider.DataGridProvider.DataGrid.InvokeSync (delegate {
74	if (currentCell.ColumnNumber == 0 && currentCell.RowNumber == itemProvider.Index) {	74	SWF.DataGridCell currentCell = itemProvider.DataGridProvider.DataGrid.CurrentCell;
75	if (focused)	75	if (currentCell.ColumnNumber == 0 && currentCell.RowNumber == itemProvider.Index) {
76	RaiseAutomationEvent ();	76	if (focused)
77	focused = !focused;	77	RaiseAutomationEvent ();
78	}	78	focused = !focused;
		79	}
		80	});
79	}	81	}
80		82
81	#endregion	83	#endregion

Lines 63-71 namespace Mono.UIAutomation.Winforms.Events.DataGrid Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/DataGrid/DataItemAutomationHasKeyboardFocusPropertyEvent.cs (-3 / +5 lines)
63		63
64	private void OnCurrentCellChanged (object sender, EventArgs args)	64	private void OnCurrentCellChanged (object sender, EventArgs args)
65	{	65	{
66	SWF.DataGridCell currentCell = itemProvider.DataGridProvider.DataGrid.CurrentCell;	66	itemProvider.DataGridProvider.DataGrid.InvokeSync (delegate {
67	if (currentCell.ColumnNumber == 0 && currentCell.RowNumber == itemProvider.Index)	67	SWF.DataGridCell currentCell = itemProvider.DataGridProvider.DataGrid.CurrentCell;
68	RaiseAutomationPropertyChangedEvent ();	68	if (currentCell.ColumnNumber == 0 && currentCell.RowNumber == itemProvider.Index)
		69	RaiseAutomationPropertyChangedEvent ();
		70	});
69	}	71	}
70		72
71	#endregion	73	#endregion

Lines 71-83 namespace Mono.UIAutomation.Winforms.Events.DataGrid Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/DataGrid/DataItemSelectionItemPatternElementAddedEvent.cs (-7 / +9 lines)
71		71
72	ListItemProvider provider = (ListItemProvider) Provider;	72	ListItemProvider provider = (ListItemProvider) Provider;
73	SWF.DataGrid datagrid = (SWF.DataGrid) sender;	73	SWF.DataGrid datagrid = (SWF.DataGrid) sender;
74		74
75	if (!selected	75	datagrid.InvokeSync (delegate {
76	&& datagrid.UIASelectedRows > 1	76	if (!selected
77	&& datagrid.IsSelected (provider.Index))	77	&& datagrid.UIASelectedRows > 1
78	RaiseAutomationEvent ();	78	&& datagrid.IsSelected (provider.Index))
79		79	RaiseAutomationEvent ();
80	selected = datagrid.IsSelected (provider.Index);	80
		81	selected = datagrid.IsSelected (provider.Index);
		82	});
81	}	83	}
82		84
83	#endregion	85	#endregion

Lines 71-77 namespace Mono.UIAutomation.Winforms.Events.DataGridView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/DataGridView/DataItemChildSelectionItemPatternElementAddedEvent.cs (-1 / +1 lines)
71	if (args.Cell.RowIndex == provider.Cell.RowIndex) {	71	if (args.Cell.RowIndex == provider.Cell.RowIndex) {
72	if (wasSelected != isSelected	72	if (wasSelected != isSelected
73	&& isSelected	73	&& isSelected
74	&& provider.DataGridViewProvider.DataGridView.SelectedCells.Count > 1) {	74	&& provider.DataGridViewProvider.DataGridView.InvokeSync (d => d.SelectedCells.Count) > 1) {
75	RaiseAutomationEvent ();	75	RaiseAutomationEvent ();
76	}	76	}
77		77

Lines 71-77 namespace Mono.UIAutomation.Winforms.Events.DataGridView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/DataGridView/DataItemChildSelectionItemPatternElementRemovedEvent.cs (-1 / +1 lines)
71	if (args.Cell.RowIndex == provider.Cell.RowIndex	71	if (args.Cell.RowIndex == provider.Cell.RowIndex
72	&& wasSelected	72	&& wasSelected
73	&& !selectionStatus	73	&& !selectionStatus
74	&& provider.DataGridViewProvider.DataGridView.SelectedCells.Count > 1)	74	&& provider.DataGridViewProvider.DataGridView.InvokeSync (d => d.SelectedCells.Count) > 1)
75	RaiseAutomationEvent ();	75	RaiseAutomationEvent ();
76		76
77	wasSelected = selectionStatus;	77	wasSelected = selectionStatus;

Lines 62-72 namespace Mono.UIAutomation.Winforms.Events.DataGridView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/DataGridView/DataItemChildSelectionItemPatternElementSelectedEvent.cs (-5 / +7 lines)
62	private void OnCellStateChanged (object sender,	62	private void OnCellStateChanged (object sender,
63	SWF.DataGridViewCellStateChangedEventArgs args)	63	SWF.DataGridViewCellStateChangedEventArgs args)
64	{	64	{
65	if (provider.DataGridViewProvider.DataGridView.SelectedCells.Count == 1	65	provider.DataGridViewProvider.DataGridView.InvokeSync (delegate {
66	&& args.Cell.RowIndex == provider.Cell.RowIndex	66	if (provider.DataGridViewProvider.DataGridView.SelectedCells.Count == 1
67	&& args.Cell.ColumnIndex == provider.Cell.ColumnIndex	67	&& args.Cell.RowIndex == provider.Cell.RowIndex
68	&& provider.Cell.Selected)	68	&& args.Cell.ColumnIndex == provider.Cell.ColumnIndex
69	RaiseAutomationEvent ();	69	&& provider.Cell.Selected)
		70	RaiseAutomationEvent ();
		71	});
70	}	72	}
71		73
72	private DataGridViewProvider.DataGridViewDataItemChildProvider provider;	74	private DataGridViewProvider.DataGridViewDataItemChildProvider provider;

Lines 68-74 namespace Mono.UIAutomation.Winforms.Events.DataGridView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/DataGridView/DataItemSelectionItemPatternElementAddedEvent.cs (-1 / +1 lines)
68	if (args.Cell.RowIndex == provider.Row.Index) {	68	if (args.Cell.RowIndex == provider.Row.Index) {
69	if (wasSelected != isSelected	69	if (wasSelected != isSelected
70	&& isSelected	70	&& isSelected
71	&& provider.DataGridView.SelectedCells.Count > 1) {	71	&& provider.DataGridView.InvokeSync (d => d.SelectedCells.Count) > 1) {
72	RaiseAutomationEvent ();	72	RaiseAutomationEvent ();
73	}	73	}
74		74

Lines 71-77 namespace Mono.UIAutomation.Winforms.Events.DataGridView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/DataGridView/DataItemSelectionItemPatternElementRemovedEvent.cs (-1 / +1 lines)
71	if (args.Cell.RowIndex == provider.Row.Index	71	if (args.Cell.RowIndex == provider.Row.Index
72	&& selected	72	&& selected
73	&& !selectionStatus	73	&& !selectionStatus
74	&& provider.DataGridView.SelectedCells.Count > 1)	74	&& provider.DataGridView.InvokeSync (d => d.SelectedCells.Count) > 1)
75	RaiseAutomationEvent ();	75	RaiseAutomationEvent ();
76		76
77	selected = selectionStatus;	77	selected = selectionStatus;

Lines 62-72 namespace Mono.UIAutomation.Winforms.Events.DataGridView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/DataGridView/DataItemSelectionItemPatternElementSelectedEvent.cs (-5 / +7 lines)
62	private void OnCellStateChagned (object sender,	62	private void OnCellStateChagned (object sender,
63	SWF.DataGridViewCellStateChangedEventArgs args)	63	SWF.DataGridViewCellStateChangedEventArgs args)
64	{	64	{
65	if (args.Cell.ColumnIndex == 0	65	provider.DataGridView.InvokeSync (delegate {
66	&& args.Cell.RowIndex == provider.Row.Index	66	if (args.Cell.ColumnIndex == 0
67	&& provider.DataGridView.SelectedCells.Count == 1	67	&& args.Cell.RowIndex == provider.Row.Index
68	&& provider.DataGridViewProvider.IsItemSelected ((ListItemProvider) provider))	68	&& provider.DataGridView.SelectedCells.Count == 1
69	RaiseAutomationEvent ();	69	&& provider.DataGridViewProvider.IsItemSelected ((ListItemProvider) provider))
		70	RaiseAutomationEvent ();
		71	});
70	}	72	}
71		73
72	private DataGridViewProvider.DataGridDataItemProvider provider;	74	private DataGridViewProvider.DataGridDataItemProvider provider;

Lines 68-76 namespace Mono.UIAutomation.Winforms.Events.ListBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/ListBox/ListItemSelectionItemPatternElementSelectedEvent.cs (-3 / +5 lines)
68	{	68	{
69	ListItemProvider provider = (ListItemProvider) Provider;	69	ListItemProvider provider = (ListItemProvider) Provider;
70		70
71	if (((SWF.ListBox) provider.Control).SelectedIndex == provider.Index	71	((SWF.ListBox) provider.Control).InvokeSync (c => {
72	&& provider.ListProvider.SelectedItemsCount == 1)	72	if (c.SelectedIndex == provider.Index
73	RaiseAutomationEvent ();	73	&& provider.ListProvider.SelectedItemsCount == 1)
		74	RaiseAutomationEvent ();
		75	});
74	}	76	}
75		77
76	#endregion	78	#endregion

Lines 60-68 namespace Mono.UIAutomation.Winforms.Events.ListView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/ListView/HeaderItemAutomationBoundingRectanglePropertyEvent.cs (-3 / +5 lines)
60		60
61	private void OnColumnWidthChanged (object sender, ColumnWidthChangedEventArgs args)	61	private void OnColumnWidthChanged (object sender, ColumnWidthChangedEventArgs args)
62	{	62	{
63	if (args.ColumnIndex	63	itemProvider.HeaderProvider.ListView.InvokeSync (delegate {
64	== itemProvider.HeaderProvider.ListView.Columns.IndexOf (itemProvider.ColumnHeader))	64	if (args.ColumnIndex
65	RaiseAutomationPropertyChangedEvent ();	65	== itemProvider.HeaderProvider.ListView.Columns.IndexOf (itemProvider.ColumnHeader))
		66	RaiseAutomationPropertyChangedEvent ();
		67	});
66	}	68	}
67		69
68	#endregion	70	#endregion

Lines 60-68 namespace Mono.UIAutomation.Winforms.Events.ListView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/ListView/HeaderItemAutomationIsOffScreenPropertyEvent.cs (-3 / +5 lines)
60		60
61	private void OnColumnWidthChanged (object sender, ColumnWidthChangedEventArgs args)	61	private void OnColumnWidthChanged (object sender, ColumnWidthChangedEventArgs args)
62	{	62	{
63	if (args.ColumnIndex	63	itemProvider.HeaderProvider.ListView.InvokeSync (delegate {
64	== itemProvider.HeaderProvider.ListView.Columns.IndexOf (itemProvider.ColumnHeader))	64	if (args.ColumnIndex
65	RaiseAutomationPropertyChangedEvent ();	65	== itemProvider.HeaderProvider.ListView.Columns.IndexOf (itemProvider.ColumnHeader))
		66	RaiseAutomationPropertyChangedEvent ();
		67	});
66	}	68	}
67		69
68	#endregion	70	#endregion

Lines 61-79 namespace Mono.UIAutomation.Winforms.Events.ListView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/ListView/ListItemEditValuePatternValueEvent.cs (-9 / +13 lines)
61		61
62	private void OnUIATextChanged (object sender, SWF.LabelEditEventArgs args)	62	private void OnUIATextChanged (object sender, SWF.LabelEditEventArgs args)
63	{	63	{
64	if (args.Item == editProvider.ItemProvider.ListView.Columns.IndexOf (editProvider.ColumnHeader)) {	64	editProvider.ItemProvider.ListView.InvokeSync (delegate {
65	newText = (string) editProvider.GetPropertyValue (ValuePatternIdentifiers.ValueProperty.Id);	65	if (args.Item == editProvider.ItemProvider.ListView.Columns.IndexOf (editProvider.ColumnHeader)) {
66	RaiseAutomationPropertyChangedEvent ();	66	newText = (string) editProvider.GetPropertyValue (ValuePatternIdentifiers.ValueProperty.Id);
67	}	67	RaiseAutomationPropertyChangedEvent ();
		68	}
		69	});
68	}	70	}
69		71
70	private void OnAfterLabelEdit (object sender, SWF.LabelEditEventArgs args)	72	private void OnAfterLabelEdit (object sender, SWF.LabelEditEventArgs args)
71	{	73	{
72	if (editProvider.ItemProvider.ListView.Items.IndexOf (editProvider.ItemProvider.ListViewItem)	74	editProvider.ItemProvider.ListView.InvokeSync (delegate {
73	== args.Item) {	75	if (editProvider.ItemProvider.ListView.Items.IndexOf (editProvider.ItemProvider.ListViewItem)
74	newText = args.Label;	76	== args.Item) {
75	RaiseAutomationPropertyChangedEvent ();	77	newText = args.Label;
76	}	78	RaiseAutomationPropertyChangedEvent ();
		79	}
		80	});
77	}	81	}
78		82
79	//We are doing this because AfterLabelEdit event is generated before commiting the text	83	//We are doing this because AfterLabelEdit event is generated before commiting the text

Lines 66-78 namespace Mono.UIAutomation.Winforms.Events.ListView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/ListView/ListItemSelectionItemPatternElementAddedEvent.cs (-7 / +9 lines)
66	{	66	{
67	ListItemProvider provider = (ListItemProvider) Provider;	67	ListItemProvider provider = (ListItemProvider) Provider;
68	SWF.ListView listView = (SWF.ListView) sender;	68	SWF.ListView listView = (SWF.ListView) sender;
69		69
70	if (selected == false	70	listView.InvokeSync (delegate {
71	&& listView.SelectedIndices.Count > 1	71	if (selected == false
72	&& listView.SelectedIndices.Contains (provider.Index) == true)	72	&& listView.SelectedIndices.Count > 1
73	RaiseAutomationEvent ();	73	&& listView.SelectedIndices.Contains (provider.Index) == true)
74		74	RaiseAutomationEvent ();
75	selected = listView.SelectedIndices.Contains (provider.Index);	75
		76	selected = listView.SelectedIndices.Contains (provider.Index);
		77	});
76	}	78	}
77		79
78	#endregion	80	#endregion

Lines 68-80 namespace Mono.UIAutomation.Winforms.Events.ListView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/ListView/ListItemSelectionItemPatternElementRemovedEvent.cs (-7 / +9 lines)
68	{	68	{
69	ListItemProvider provider = (ListItemProvider) Provider;	69	ListItemProvider provider = (ListItemProvider) Provider;
70	SWF.ListView listView = (SWF.ListView) sender;	70	SWF.ListView listView = (SWF.ListView) sender;
71		71
72	if (selected == true	72	listView.InvokeSync (delegate {
73	&& listView.SelectedIndices.Count > 1	73	if (selected == true
74	&& listView.SelectedIndices.Contains (provider.Index) == false)	74	&& listView.SelectedIndices.Count > 1
75	RaiseAutomationEvent ();	75	&& listView.SelectedIndices.Contains (provider.Index) == false)
76		76	RaiseAutomationEvent ();
77	selected = listView.SelectedIndices.Contains (provider.Index);	77
		78	selected = listView.SelectedIndices.Contains (provider.Index);
		79	});
78	}	80	}
79		81
80	#endregion	82	#endregion

Lines 65-74 namespace Mono.UIAutomation.Winforms.Events.ListView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/ListView/ListItemSelectionItemPatternElementSelectedEvent.cs (-4 / +6 lines)
65	{	65	{
66	ListItemProvider provider = (ListItemProvider) Provider;	66	ListItemProvider provider = (ListItemProvider) Provider;
67	SWF.ListView listView = (SWF.ListView) sender;	67	SWF.ListView listView = (SWF.ListView) sender;
68		68
69	if (listView.SelectedIndices.Count == 1	69	listView.InvokeSync (delegate {
70	&& listView.SelectedIndices.Contains (provider.Index) == true)	70	if (listView.SelectedIndices.Count == 1
71	RaiseAutomationEvent ();	71	&& listView.SelectedIndices.Contains (provider.Index) == true)
		72	RaiseAutomationEvent ();
		73	});
72	}	74	}
73		75
74	#endregion	76	#endregion

Lines 67-79 namespace Mono.UIAutomation.Winforms.Events.ListView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/ListView/ListItemSelectionItemPatternIsSelectedEvent.cs (-7 / +9 lines)
67	{	67	{
68	SWF.ListView listView = (SWF.ListView) sender;	68	SWF.ListView listView = (SWF.ListView) sender;
69	ListItemProvider provider = (ListItemProvider) Provider;	69	ListItemProvider provider = (ListItemProvider) Provider;
70		70
71	bool selectedChanged = listView.SelectedIndices.Contains (provider.Index);	71	listView.InvokeSync (delegate {
72		72	bool selectedChanged = listView.SelectedIndices.Contains (provider.Index);
73	if (selectedChanged != selected) {	73
74	RaiseAutomationPropertyChangedEvent ();	74	if (selectedChanged != selected) {
75	selected = selectedChanged;	75	RaiseAutomationPropertyChangedEvent ();
76	}	76	selected = selectedChanged;
		77	}
		78	});
77	}	79	}
78		80
79	#endregion	81	#endregion

Lines 59-65 namespace Mono.UIAutomation.Winforms.Events.RadioButton Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/RadioButton/SelectionItemPatternElementSelectedEvent.cs (-1 / +1 lines)
59		59
60	private void OnElementSelectedEvent (object sender, System.EventArgs e)	60	private void OnElementSelectedEvent (object sender, System.EventArgs e)
61	{	61	{
62	if (((SWF.RadioButton) Provider.Control).Checked)	62	if (((SWF.RadioButton) Provider.Control).InvokeSync (c => c.Checked))
63	RaiseAutomationEvent ();	63	RaiseAutomationEvent ();
64	}	64	}
65		65

Lines 63-69 namespace Mono.UIAutomation.Winforms.Events.TextBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/TextBox/TextPatternCaretMovedEvent.cs (-1 / +1 lines)
63	if (Provider.Control is SWF.TextBoxBase)	63	if (Provider.Control is SWF.TextBoxBase)
64	return (SWF.TextBoxBase)Provider.Control;	64	return (SWF.TextBoxBase)Provider.Control;
65	else if (Provider.Control is SWF.UpDownBase)	65	else if (Provider.Control is SWF.UpDownBase)
66	return ((SWF.UpDownBase)Provider.Control).txtView;	66	return ((SWF.UpDownBase)Provider.Control).InvokeSync (c => c.txtView);
67	else	67	else
68	throw new Exception ("TextBoxBase: Unknown type: " + Provider.Control);	68	throw new Exception ("TextBoxBase: Unknown type: " + Provider.Control);
69	}	69	}

Lines 73-79 namespace Mono.UIAutomation.Winforms.Events.TextBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/TextBox/TextPatternTextSelectionChangedEvent.cs (-2 / +2 lines)
73	private void OnSelectionChangedEvent (object sender,	73	private void OnSelectionChangedEvent (object sender,
74	EventArgs args)	74	EventArgs args)
75	{	75	{
76	SWF.Document document = TextBoxBase.Document;	76	SWF.Document document = TextBoxBase.InvokeSync (c => c.Document);
77	if (!selectionVisible && !document.selection_visible)	77	if (!selectionVisible && !document.selection_visible)
78	return;	78	return;
79	if (document.selection_visible != selectionVisible \|\| document.selection_start != selectionStart \|\| document.selection_end != selectionEnd) {	79	if (document.selection_visible != selectionVisible \|\| document.selection_start != selectionStart \|\| document.selection_end != selectionEnd) {
Lines 89-95 namespace Mono.UIAutomation.Winforms.Events.TextBox Link Here
89	if (Provider.Control is SWF.TextBoxBase)	89	if (Provider.Control is SWF.TextBoxBase)
90	return (SWF.TextBoxBase)Provider.Control;	90	return (SWF.TextBoxBase)Provider.Control;
91	else if (Provider.Control is SWF.UpDownBase)	91	else if (Provider.Control is SWF.UpDownBase)
92	return ((SWF.UpDownBase)Provider.Control).txtView;	92	return ((SWF.UpDownBase)Provider.Control).InvokeSync (c => c.txtView);
93	else	93	else
94	throw new Exception ("TextBoxBase: Unknown type: " + Provider.Control);	94	throw new Exception ("TextBoxBase: Unknown type: " + Provider.Control);
95	}	95	}




				} else {
					AddElementAt (args.Index, args.ChildProvider.Navigation);
				}

				
				if (args.RaiseEvent == true) {
//					Helper.DelegateQueue.Get ().Enqueue (delegate {
					Helper.RaiseStructureChangedEvent (StructureChangeType.ChildAdded, 
					                                   args.ChildProvider);
					Helper.RaiseStructureChangedEvent (StructureChangeType.ChildrenInvalidated,
					                                   (FragmentControlProvider) sender);
//					});
				}
			} else if (args.ChangeType == StructureChangeType.ChildRemoved) {
				Remove (args.ChildProvider.Navigation);
	
				if (args.RaiseEvent == true) {
//					Helper.DelegateQueue.Get ().Enqueue (delegate {
					Helper.RaiseStructureChangedEvent (StructureChangeType.ChildRemoved, 
					                                   args.ChildProvider);
					Helper.RaiseStructureChangedEvent (StructureChangeType.ChildrenInvalidated,
					                                   (FragmentControlProvider) sender);
//					});
				}
			} else if (args.ChangeType == StructureChangeType.ChildrenReordered) {
				chain.Clear ();
				
				//TODO: Is this the event to generate?
				if (args.RaiseEvent == true) {
//					Helper.DelegateQueue.Get ().Enqueue (delegate {
					Helper.RaiseStructureChangedEvent (StructureChangeType.ChildrenBulkRemoved, 
					                                   (FragmentControlProvider) sender);
					Helper.RaiseStructureChangedEvent (StructureChangeType.ChildrenInvalidated,
					                                   (FragmentControlProvider) sender);
//					});
				}
			}
		}




    <File name="Mono.UIAutomation.Winforms/RadioButtonProvider.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms/LabelProvider.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms/TextBoxProvider.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms/Helper.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms/LinkLabelProvider.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms.Events/AutomationHasKeyboardFocusPropertyEvent.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms.Events/AutomationBoundingRectanglePropertyEvent.cs" subtype="Code" buildaction="Compile" />

    <File name="Mono.UIAutomation.Winforms.Events/MonthCalendar/AutomationNamePropertyEvent.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms.Events/PopupButton/AutomationHasKeyboardFocusPropertyEvent.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms.Events/ToolStripButton/TogglePatternToggleStateEvent.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms/Helper.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms.Behaviors/PropertyGrid/CategoryInvokeProviderBehavior.cs" subtype="Code" buildaction="Compile" />
  </Contents>
  <References>

    <ProjectReference type="Gac" localcopy="True" refto="System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
    <ProjectReference type="Gac" localcopy="True" refto="UIAutomationTypes, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
    <ProjectReference type="Gac" localcopy="True" refto="UIAutomationProvider, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
    <ProjectReference type="Gac" localcopy="True" refto="System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
    <ProjectReference type="Gac" localcopy="True" refto="glib-sharp, Version=2.14.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" />
    <ProjectReference type="Gac" localcopy="True" refto="atk-sharp, Version=2.14.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" />
    <ProjectReference type="Gac" localcopy="True" refto="Mono.WebBrowser, Version=0.5.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756" />
    <ProjectReference type="Gac" localcopy="True" refto="System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
  </References>
  <MonoDevelop.Autotools.MakefileInfo IntegrationEnabled="True" RelativeMakefileName="Makefile.am" IsAutotoolsProject="True" RelativeConfigureInPath="..">
    <BuildFilesVar Sync="True" Name="FILES" />

    <AsmRefVar Name="REFERENCES" />
    <ProjectRefVar Name="REFERENCES" />
  </MonoDevelop.Autotools.MakefileInfo>
</Project>

Lines 75-81 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/BalloonWindowProvider.cs (-1 / +1 lines)
75	protected override object GetProviderPropertyValue (int propertyId)	75	protected override object GetProviderPropertyValue (int propertyId)
76	{	76	{
77	if (propertyId == AutomationElementIdentifiers.HelpTextProperty.Id)	77	if (propertyId == AutomationElementIdentifiers.HelpTextProperty.Id)
78	return balloon.AccessibleDescription?? balloon.Title;	78	return balloon.InvokeSync (c => c.AccessibleDescription ?? c.Title);
79	else if (propertyId == AutomationElementIdentifiers.IsNotifyIconProperty.Id)	79	else if (propertyId == AutomationElementIdentifiers.IsNotifyIconProperty.Id)
80	return true;	80	return true;
81	else	81	else

Lines 52-59 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/CheckedListBoxProvider.cs (-3 / +6 lines)
52	{	52	{
53	if (ContainsItem (item) == true) {	53	if (ContainsItem (item) == true) {
54	SWF.CheckedListBox checkedListBox = (SWF.CheckedListBox) Control;	54	SWF.CheckedListBox checkedListBox = (SWF.CheckedListBox) Control;
55	bool chcked = checkedListBox.GetItemChecked (item.Index);	55	checkedListBox.InvokeSync (delegate {
56	checkedListBox.SetItemChecked (item.Index, !chcked);	56	bool chcked = checkedListBox.GetItemChecked (item.Index);
		57	checkedListBox.SetItemChecked (item.Index, !chcked);
		58	});
57	}	59	}
58	}	60	}
59		61
Lines 62-68 namespace Mono.UIAutomation.Winforms Link Here
62	if (ContainsItem (item) == true) {	64	if (ContainsItem (item) == true) {
63	SWF.CheckedListBox checkedListBox = (SWF.CheckedListBox) Control;	65	SWF.CheckedListBox checkedListBox = (SWF.CheckedListBox) Control;
64		66
65	SWF.CheckState state = checkedListBox.GetItemCheckState (item.Index);	67	SWF.CheckState state
		68	= checkedListBox.InvokeSync (c => c.GetItemCheckState (item.Index));
66	switch (state) {	69	switch (state) {
67	case SWF.CheckState.Checked:	70	case SWF.CheckState.Checked:
68	return ToggleState.On;	71	return ToggleState.On;




			else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)
				return Catalog.GetString ("combo box");
			else if (propertyId == AEIds.HasKeyboardFocusProperty.Id
			         && comboboxControl.InvokeSync (b => b.DropDownStyle == SWF.ComboBoxStyle.DropDown))
				return false;
			else
				return base.GetProviderPropertyValue (propertyId);

		
		public override IRawElementProviderFragment GetFocus ()
		{
			return comboboxControl.InvokeSync (c => listboxProvider.GetItemProviderFrom (listboxProvider, c.SelectedItem));
			                                            comboboxControl.SelectedItem);
		}		
		
		public override IRawElementProviderFragment ElementProviderFromPoint (double x, double y)

		
		private void UpdateBehaviors (bool updateAssociatedChildren) 
		{
			SWF.ComboBoxStyle style 
				= comboboxControl.InvokeSync (c => c.DropDownStyle);
			
			if (style == SWF.ComboBoxStyle.Simple) {
				SetBehavior (ExpandCollapsePatternIdentifiers.Pattern, 
				             null);
				if (!IsBehaviorEnabled (ValuePatternIdentifiers.Pattern))

					TerminateButtonProvider ();
					InitializeEditProvider ();
				}
			} else if (style == SWF.ComboBoxStyle.DropDown) {
				if (!IsBehaviorEnabled (ExpandCollapsePatternIdentifiers.Pattern))
					SetBehavior (ExpandCollapsePatternIdentifiers.Pattern,
					             new ExpandCollapseProviderBehavior (this));

					InitializeButtonProvider ();
					InitializeEditProvider ();
				}
			} else if (style == SWF.ComboBoxStyle.DropDownList) {
				if (!IsBehaviorEnabled (ExpandCollapsePatternIdentifiers.Pattern))
					SetBehavior (ExpandCollapsePatternIdentifiers.Pattern,
					             new ExpandCollapseProviderBehavior (this));

					else
						return Helper.GetControlScreenBounds (listboxControl.Bounds, listboxControl);
				} else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id) {
					if (comboboxControl.InvokeSync (s => s.DropDownStyle)
					    == SWF.ComboBoxStyle.Simple)
						return false;
					
					IExpandCollapseProvider pattern 

			}

			public override int SelectedItemsCount {
				get {
					return comboboxControl.InvokeSync (c => c.SelectedIndex == -1 ? 0 : 1);
				}
			}
			
			public override int ItemsCount {
				get {
					return comboboxControl.InvokeSync (c => c.Items.Count);
				}
			}

			public override int IndexOfObjectItem (object objectItem)
			{
				return comboboxControl.InvokeSync (c => c.Items.IndexOf (objectItem));
			}	

			public override IRawElementProviderSimple[] GetSelectedItems ()
			{
				if (comboboxControl == null)
					return new IRawElementProviderSimple [0];
				return comboboxControl.InvokeSync (c => {
					if (c.SelectedIndex == -1)
						return new IRawElementProviderSimple [0];
					else
						return new IRawElementProviderSimple [] { GetItemProviderFrom (this,
						                                                               c.SelectedItem) };
				});
			}

			public override void SelectItem (ListItemProvider item)
			{
				if (ContainsItem (item) == true) {
					comboboxControl.InvokeSync (delegate {
						comboboxControl.SelectedIndex = item.Index;
						// Raise SelectionChangeCommitted event
						// on the ComboBox. Since we are simulating
						// a user interacting with the control,
						// this event is expected.
						//
						// NOTE: This is a protected method that
						//       is a part of the documented
						//       API for SWF.ComboBox.
						MethodInfo onSelectionChangeCommitted =
							comboboxControl.GetType ().GetMethod ("OnSelectionChangeCommitted",
							                                      BindingFlags.NonPublic | BindingFlags.Instance);
						if (onSelectionChangeCommitted != null) {
							onSelectionChangeCommitted.Invoke (comboboxControl,
								                                   new object [] {EventArgs.Empty});
						}
					});
				}
			}
	
			public override void UnselectItem (ListItemProvider item)
			{
				if (ContainsItem (item) == true)
					comboboxControl.InvokeSync (delegate {
						comboboxControl.SelectedIndex = -1;
					});
			}
			
			public override bool IsItemSelected (ListItemProvider item)
			{
				if (!ContainsItem (item))
					return false;
				else
					return comboboxControl.InvokeSync (c => {
						return item.Index == c.SelectedIndex; });
			}

			public override void InitializeChildControlStructure ()


				comboboxControl.Items.UIACollectionChanged += OnCollectionChanged;

				foreach (object objectItem 
				         in comboboxControl.InvokeSync (c => c.Items)) {
					ListItemProvider item = GetItemProviderFrom (this, objectItem);
					AddChildProvider (item);
				}

			                                             int propertyId)
			{
				if (propertyId == AutomationElementIdentifiers.NameProperty.Id)
					return comboboxControl.InvokeSync (c => c.GetItemText (item.ObjectItem));

				int topItem = -1;
				if (ListBoxControl != null)
					topItem = ListBoxControl.UIATopItem;

				if (ContainsItem (item) == false)
					return null;
				else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)
					return comboboxControl.InvokeSync (b => b.Focused && item.Index == b.SelectedIndex);
				else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {
					//FIXME: We need to improve this
					int index = item.Index;

					System.Drawing.Rectangle bounds = System.Drawing.Rectangle.Empty;

					if (ListBoxControl == null)
						bounds = comboboxControl.InvokeSync (c => c.Bounds);
					else
						bounds = ListBoxControl.InvokeSync (c => c.Bounds);

					int itemHeight = comboboxControl.InvokeSync (c => c.GetItemHeight (0));// TODO: always true?
					rectangle.Height = comboboxControl.InvokeSync (c => c.GetItemHeight (index));
					rectangle.Width = bounds.Width;
					rectangle.X = bounds.X;
					rectangle.Y = bounds.Y + (index * itemHeight) - (topItem * itemHeight);// decreaseY;

					else
						return Helper.GetControlScreenBounds (rectangle, ListBoxControl);
				} else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id) {
					return comboboxControl.InvokeSync (c => {
						if (c.SelectedIndex == item.Index)
							return false;
						
						if (topItem == -1 || !ListBoxControl.Visible)
							return !(c.SelectedIndex == item.Index);
	
						int lastItem = ListBoxControl.UIALastItem;				
						if ((item.Index >= topItem && item.Index < lastItem) 
						    || (item.Index == lastItem && c.Items.Count == lastItem + 1))
							return false;
						else
						return true;
					});
				} else
					return null;
			}

					// This control cannot be selected, but
					// it can still be keyboard focused, so
					// we override it manually.
					return Control.InvokeSync (c => c.CanFocus);
				}

				return base.GetProviderPropertyValue (propertyId);




		{
			base.Initialize ();

//			System.Threading.ThreadPool.QueueUserWorkItem (v => {

			AutomationEventArgs args = new AutomationEventArgs (AEIds.MenuOpenedEvent);
			AutomationInteropProvider.RaiseAutomationEvent (AEIds.MenuOpenedEvent,
			                                                this,
			                                                args);
//			});
		}

		public override void Terminate ()
		{
//			System.Threading.ThreadPool.QueueUserWorkItem (v => {
			AutomationEventArgs args = new AutomationEventArgs (AEIds.MenuClosedEvent);
			AutomationInteropProvider.RaiseAutomationEvent (AEIds.MenuClosedEvent,
			                                                this,
			                                                args);
//			});
			base.Terminate ();
		}
		




		public override void Initialize ()
		{
			base.Initialize ();
//			System.Threading.ThreadPool.QueueUserWorkItem (v => {

			AutomationEventArgs args = new AutomationEventArgs (AEIds.MenuOpenedEvent);
			AutomationInteropProvider.RaiseAutomationEvent (AEIds.MenuOpenedEvent,
			                                                this,
			                                                args);
//			});
		}

		public override void Terminate ()
		{
//			System.Threading.ThreadPool.QueueUserWorkItem (v => {
			AutomationEventArgs args = new AutomationEventArgs (AEIds.MenuClosedEvent);
			AutomationInteropProvider.RaiseAutomationEvent (AEIds.MenuClosedEvent,
			                                                this,
			                                                args);
//			});
			base.Terminate ();
		}


Lines 57-63 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/DataGridProvider.cs (-86 / +113 lines)
57	#region Public Properties	57	#region Public Properties
58		58
59	public SWF.DataGridTableStyle CurrentTableStyle {	59	public SWF.DataGridTableStyle CurrentTableStyle {
60	get { return datagrid.UIACurrentTableStyle; }	60	get { return datagrid.InvokeSync (v => v.UIACurrentTableStyle); }
61	}	61	}
62		62
63	public SWF.CurrencyManager CurrencyManager {	63	public SWF.CurrencyManager CurrencyManager {
Lines 137-147 namespace Mono.UIAutomation.Winforms Link Here
137	new SelectionProviderBehavior (this));	137	new SelectionProviderBehavior (this));
138	SetBehavior (GridPatternIdentifiers.Pattern,	138	SetBehavior (GridPatternIdentifiers.Pattern,
139	new GridProviderBehavior (this));	139	new GridProviderBehavior (this));
140		140
141	// Table Pattern is only supported when Header exists	141	datagrid.InvokeSync (delegate {
142	if (datagrid.CurrentTableStyle.GridColumnStyles.Count > 0	142	// Table Pattern is only supported when Header exists
143	&& datagrid.ColumnHeadersVisible)	143	if (datagrid.CurrentTableStyle.GridColumnStyles.Count > 0
144	CreateHeader (datagrid.CurrentTableStyle);	144	&& datagrid.ColumnHeadersVisible)
		145	CreateHeader (datagrid.CurrentTableStyle);
		146	});
145	}	147	}
146		148
147	public override void Terminate ()	149	public override void Terminate ()
Lines 213-220 namespace Mono.UIAutomation.Winforms Link Here
213	public void FocusItem (object objectItem)	215	public void FocusItem (object objectItem)
214	{	216	{
215	int row = (int) objectItem;	217	int row = (int) objectItem;
216	datagrid.Focus ();	218	datagrid.InvokeSync (delegate {
217	datagrid.CurrentCell = new SWF.DataGridCell (row, 0);	219	datagrid.Focus ();
		220	datagrid.CurrentCell = new SWF.DataGridCell (row, 0);
		221	});
218	}	222	}
219		223
220	public int SelectedItemsCount {	224	public int SelectedItemsCount {
Lines 231-260 namespace Mono.UIAutomation.Winforms Link Here
231	if (!items.Contains (item))	235	if (!items.Contains (item))
232	return false;	236	return false;
233		237
234	return datagrid.IsSelected (item.Index);	238	return datagrid.InvokeSync (v => v.IsSelected (item.Index));
235	}	239	}
236		240
237	public void SelectItem (ListItemProvider item)	241	public void SelectItem (ListItemProvider item)
238	{	242	{
239	if (items.Contains (item))	243	if (items.Contains (item))
240	datagrid.Select (item.Index);	244	datagrid.InvokeSync (delegate { datagrid.Select (item.Index); });
241	}	245	}
242		246
243	public void UnselectItem (ListItemProvider item)	247	public void UnselectItem (ListItemProvider item)
244	{	248	{
245	if (items.Contains (item))	249	if (items.Contains (item))
246	datagrid.UnSelect (item.Index);	250	datagrid.InvokeSync (delegate { datagrid.UnSelect (item.Index); });
247	}	251	}
248		252
249	public object GetItemPropertyValue (ListItemProvider item,	253	public object GetItemPropertyValue (ListItemProvider item,
250	int propertyId)	254	int propertyId)
251	{	255	{
252	if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {	256	if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {
253	int index = item.Index;	257	return datagrid.InvokeSync (d => {
254	// We need to union last column and first column	258	int index = item.Index;
255	SD.Rectangle rect0 = datagrid.GetCellBounds (index, 0);	259	// We need to union last column and first column
256	SD.Rectangle rectN = datagrid.GetCellBounds (index, header.ChildrenCount);	260	SD.Rectangle rect0 = d.GetCellBounds (index, 0);
257	return Helper.GetControlScreenBounds (SD.Rectangle.Union (rect0, rectN), datagrid);	261	SD.Rectangle rectN = d.GetCellBounds (index, header.ChildrenCount);
		262	return Helper.GetControlScreenBounds (SD.Rectangle.Union (rect0, rectN), d);
		263	});
258	} else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id) {	264	} else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id) {
259	Rect bounds	265	Rect bounds
260	= (Rect) GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id);	266	= (Rect) GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id);
Lines 264-272 namespace Mono.UIAutomation.Winforms Link Here
264	else if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)	270	else if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)
265	return true;	271	return true;
266	else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id) {	272	else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id) {
267	SWF.DataGridCell currentCell = datagrid.CurrentCell;	273	return datagrid.InvokeSync (d => {
268	return currentCell.ColumnNumber == 0 && currentCell.RowNumber == item.Index	274	SWF.DataGridCell currentCell = d.CurrentCell;
269	&& datagrid.Focused;	275	return currentCell.ColumnNumber == 0 && currentCell.RowNumber == item.Index
		276	&& d.Focused;
		277	});
270	} else	278	} else
271	return null;	279	return null;
272	}	280	}
Lines 275-281 namespace Mono.UIAutomation.Winforms Link Here
275	{	283	{
276	if (items.Contains (item)) {	284	if (items.Contains (item)) {
277	try {	285	try {
278	if ((bool) datagrid [item.Index, 0])	286	if (datagrid.InvokeSync (d => (bool) d [item.Index, 0]))
279	return ToggleState.On;	287	return ToggleState.On;
280	else	288	else
281	return ToggleState.Off;	289	return ToggleState.Off;
Lines 289-298 namespace Mono.UIAutomation.Winforms Link Here
289	public void ToggleItem (ListItemProvider item)	297	public void ToggleItem (ListItemProvider item)
290	{	298	{
291	if (items.Contains (item)) {	299	if (items.Contains (item)) {
292	try {	300	datagrid.InvokeSync (delegate {
293	bool value = (bool) datagrid [item.Index, 0];	301	try {
294	datagrid [item.Index, 0] = !value;	302	bool value = (bool) datagrid [item.Index, 0];
295	} catch (InvalidCastException) {}	303	datagrid [item.Index, 0] = !value;
		304	} catch (InvalidCastException) {}
		305	});
296	}	306	}
297	}	307	}
298		308
Lines 380-400 namespace Mono.UIAutomation.Winforms Link Here
380	return;	390	return;
381	}	391	}
382		392
383	// Is showing "+" to expand, this usually happens when DataSource is	393	datagrid.InvokeSync (delegate {
384	// DataSet and has more than one DataTable.	394	// Is showing "+" to expand, this usually happens when DataSource is
385	if (datagrid.CurrentTableStyle.GridColumnStyles.Count == 0) {	395	// DataSet and has more than one DataTable.
386	DataGridCustomProvider customProvider	396	if (datagrid.CurrentTableStyle.GridColumnStyles.Count == 0) {
387	= new DataGridCustomProvider (this, 0, string.Empty);	397	DataGridCustomProvider customProvider
388	customProvider.Initialize ();	398	= new DataGridCustomProvider (this, 0, string.Empty);
389	AddChildProvider (customProvider);	399	customProvider.Initialize ();
390	} else {	400	AddChildProvider (customProvider);
391	CreateHeader (datagrid.CurrentTableStyle);	401	} else {
392		402	CreateHeader (datagrid.CurrentTableStyle);
393	for (int row = 0; row < lastCurrencyManager.Count; row++)	403
394	CreateListItem (row, datagrid.CurrentTableStyle);	404	for (int row = 0; row < lastCurrencyManager.Count; row++)
395	}	405	CreateListItem (row, datagrid.CurrentTableStyle);
		406	}
396		407
397	lastDataSource = datagrid.DataSource;	408	lastDataSource = datagrid.DataSource;
		409	});
398	}	410	}
399		411
400	private void OnDataSourceChanged (object sender, EventArgs args)	412	private void OnDataSourceChanged (object sender, EventArgs args)
Lines 403-409 namespace Mono.UIAutomation.Winforms Link Here
403	SWF.CurrencyManager manager = null;	415	SWF.CurrencyManager manager = null;
404		416
405	// Happens when Navigating DataGrid	417	// Happens when Navigating DataGrid
406	if (lastDataSource == datagrid.DataSource) {	418	if (lastDataSource == datagrid.InvokeSync (d => d.DataSource)) {
407	manager = RequestCurrencyManager ();	419	manager = RequestCurrencyManager ();
408	// Only when rendering something different we refresh children	420	// Only when rendering something different we refresh children
409	if (manager != null && manager != lastCurrencyManager)	421	if (manager != null && manager != lastCurrencyManager)
Lines 421-436 namespace Mono.UIAutomation.Winforms Link Here
421		433
422	private SWF.CurrencyManager RequestCurrencyManager ()	434	private SWF.CurrencyManager RequestCurrencyManager ()
423	{	435	{
424	if (datagrid.DataSource == null)	436	return datagrid.InvokeSync (d => {
425	return null;	437	if (d.DataSource == null)
426		438	return null;
427	return (SWF.CurrencyManager) datagrid.BindingContext [datagrid.DataSource,	439
428	datagrid.DataMember];	440	return (SWF.CurrencyManager) d.BindingContext [d.DataSource, d.DataMember];
		441	});
429	}	442	}
430		443
431	private void CreateHeader (SWF.DataGridTableStyle tableStyle)	444	private void CreateHeader (SWF.DataGridTableStyle tableStyle)
432	{	445	{
433	if (!datagrid.ColumnHeadersVisible \|\| header != null)	446	if (datagrid.InvokeSync (d => !d.ColumnHeadersVisible)
		447	\|\| header != null)
434	return;	448	return;
435		449
436	header = new DataGridHeaderProvider (this, tableStyle.GridColumnStyles);	450	header = new DataGridHeaderProvider (this, tableStyle.GridColumnStyles);
Lines 513-523 namespace Mono.UIAutomation.Winforms Link Here
513	else if (propertyId == AutomationElementIdentifiers.IsEnabledProperty.Id)	527	else if (propertyId == AutomationElementIdentifiers.IsEnabledProperty.Id)
514	return true;	528	return true;
515	else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {	529	else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {
516	SD.Rectangle rectangle = provider.DataGrid.UIAColumnHeadersArea;	530	return provider.DataGrid.InvokeSync (d => {
517	rectangle.X += provider.DataGrid.Bounds.X;	531	SD.Rectangle rectangle = d.UIAColumnHeadersArea;
518	rectangle.Y += provider.DataGrid.Bounds.Y;	532	rectangle.X += d.Bounds.X;
519		533	rectangle.Y += d.Bounds.Y;
520	return Helper.GetControlScreenBounds (rectangle, provider.DataGrid);	534
		535	return Helper.GetControlScreenBounds (rectangle, d);
		536	});
521	} else if (propertyId == AutomationElementIdentifiers.ClickablePointProperty.Id)	537	} else if (propertyId == AutomationElementIdentifiers.ClickablePointProperty.Id)
522	return Helper.GetClickablePoint (this);	538	return Helper.GetClickablePoint (this);
523	else	539	else
Lines 720-727 namespace Mono.UIAutomation.Winforms Link Here
720	}	736	}
721		737
722	public object Value {	738	public object Value {
723	get { return provider.DataGrid [Index, 0]; }	739	get {
724	set { provider.DataGrid [Index, 0] = value; }	740	return provider.DataGrid.InvokeSync (o => o [Index, 0]);
		741	}
		742	set { provider.DataGrid.InvokeSync (delegate { provider.DataGrid [Index, 0] = value; }); }
725	}	743	}
726		744
727	public void SetEditValue (DataGridDataItemEditProvider edit, object value)	745	public void SetEditValue (DataGridDataItemEditProvider edit, object value)
Lines 731-737 namespace Mono.UIAutomation.Winforms Link Here
731	if (column == -1 \|\| row == -1)	749	if (column == -1 \|\| row == -1)
732	return;	750	return;
733		751
734	provider.DataGrid [row, column] = value;	752	provider.DataGrid.InvokeSync (delegate { provider.DataGrid [row, column] = value; });
735	}	753	}
736		754
737	public override void InitializeChildControlStructure ()	755	public override void InitializeChildControlStructure ()
Lines 763-770 namespace Mono.UIAutomation.Winforms Link Here
763		781
764	public override void SetFocus ()	782	public override void SetFocus ()
765	{	783	{
766	DataGridProvider.DataGrid.Focus ();	784	DataGridProvider.DataGrid.InvokeSync (delegate {
767	DataGridProvider.DataGrid.CurrentCell = new SWF.DataGridCell (Index, 0);	785	DataGridProvider.DataGrid.Focus ();
		786	DataGridProvider.DataGrid.CurrentCell = new SWF.DataGridCell (Index, 0);
		787	});
768	}	788	}
769		789
770	protected override object GetProviderPropertyValue (int propertyId)	790	protected override object GetProviderPropertyValue (int propertyId)
Lines 778-789 namespace Mono.UIAutomation.Winforms Link Here
778	return ControlType.DataItem.Id;	798	return ControlType.DataItem.Id;
779	else if (propertyId == AutomationElementIdentifiers.LocalizedControlTypeProperty.Id)	799	else if (propertyId == AutomationElementIdentifiers.LocalizedControlTypeProperty.Id)
780	return Catalog.GetString ("data item");	800	return Catalog.GetString ("data item");
781	else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id)	801	else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id)
782	return Helper.GetControlScreenBounds (DataGridProvider.DataGrid.GetCellBounds (Index, 0),	802	return DataGridProvider.DataGrid.InvokeSync (v => Helper.GetControlScreenBounds (v.GetCellBounds (Index, 0),
783	DataGridProvider.DataGrid);	803	v));
784	else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id) {	804	else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id) {
785	return IsOffScreen (DataGridProvider.DataGrid,	805	return DataGridProvider.DataGrid.InvokeSync (v => IsOffScreen (v,
786	(Rect) GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id));	806	(Rect) GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id)));;
787	} else if (propertyId == AutomationElementIdentifiers.ClickablePointProperty.Id)	807	} else if (propertyId == AutomationElementIdentifiers.ClickablePointProperty.Id)
788	return Helper.GetClickablePoint (this);	808	return Helper.GetClickablePoint (this);
789	else	809	else
Lines 792-815 namespace Mono.UIAutomation.Winforms Link Here
792		812
793	public bool IsOffScreen (SWF.DataGrid datagrid, Rect bounds)	813	public bool IsOffScreen (SWF.DataGrid datagrid, Rect bounds)
794	{	814	{
795	SD.Rectangle rectangle = datagrid.Bounds;	815	return datagrid.InvokeSync (d => {
796	rectangle.Height -= datagrid.UIACellsArea.Y - rectangle.Y - datagrid.UIARowHeight;	816	SD.Rectangle rectangle = d.Bounds;
797	rectangle.Y = datagrid.UIACellsArea.Y;	817	rectangle.Height -= d.UIACellsArea.Y - rectangle.Y - d.UIARowHeight;
798	if (datagrid.ColumnHeadersVisible) {	818	rectangle.Y = d.UIACellsArea.Y;
799	rectangle.X += datagrid.RowHeaderWidth;	819	if (d.ColumnHeadersVisible) {
800	rectangle.Y += datagrid.UIAColumnHeadersArea.Height;	820	rectangle.X += d.RowHeaderWidth;
801	rectangle.Height -= datagrid.UIACaptionArea.Height;	821	rectangle.Y += d.UIAColumnHeadersArea.Height;
802	}	822	rectangle.Height -= d.UIACaptionArea.Height;
803	if (datagrid.CaptionVisible)	823	}
804	rectangle.X += datagrid.UIACaptionArea.Height;	824	if (d.CaptionVisible)
805		825	rectangle.X += d.UIACaptionArea.Height;
806	if (rectangle.Width < 0)	826
807	rectangle.Width = 0;	827	if (rectangle.Width < 0)
808	if (rectangle.Height < 0)	828	rectangle.Width = 0;
809	rectangle.Height = 0;	829	if (rectangle.Height < 0)
810		830	rectangle.Height = 0;
811	Rect screen = Helper.RectangleToRect (datagrid.Parent.RectangleToScreen (rectangle));	831
812	return !bounds.IntersectsWith (screen);	832	Rect screen = Helper.RectangleToRect (d.Parent.RectangleToScreen (rectangle));
		833
		834	return !bounds.IntersectsWith (screen);
		835	});
813	}	836	}
814		837
815	private void OnColumnsCollectionChanged (object sender, CollectionChangeEventArgs args)	838	private void OnColumnsCollectionChanged (object sender, CollectionChangeEventArgs args)
Lines 892-900 namespace Mono.UIAutomation.Winforms Link Here
892		915
893	public override void SetFocus ()	916	public override void SetFocus ()
894	{	917	{
895	ItemProvider.DataGridProvider.DataGrid.Focus ();	918	ItemProvider.DataGridProvider.DataGrid.InvokeSync (delegate {
896	ItemProvider.DataGridProvider.DataGrid.CurrentCell = new SWF.DataGridCell (ItemProvider.Index,	919	ItemProvider.DataGridProvider.DataGrid.Focus ();
897	ItemProvider.GetColumnIndexOf (this));	920	ItemProvider.DataGridProvider.DataGrid.CurrentCell = new SWF.DataGridCell (ItemProvider.Index,
		921	ItemProvider.GetColumnIndexOf (this));
		922	});
898	}	923	}
899		924
900	public SWF.Control ContainerControl {	925	public SWF.Control ContainerControl {
Lines 931-945 namespace Mono.UIAutomation.Winforms Link Here
931	return Catalog.GetString ("edit");	956	return Catalog.GetString ("edit");
932	else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)	957	else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)
933	// ItemProvider.DataGridProvider.DataGrid.Focused should be used here, but seems SWF.DataGrid loses this state randomly	958	// ItemProvider.DataGridProvider.DataGrid.Focused should be used here, but seems SWF.DataGrid loses this state randomly
934	return ItemProvider.DataGridProvider.DataGrid.CurrentCell.RowNumber == ItemProvider.Index	959	return ItemProvider.DataGridProvider.DataGrid.InvokeSync (d => {
935	&& ItemProvider.DataGridProvider.DataGrid.CurrentCell.ColumnNumber == ItemProvider.GetColumnIndexOf (this);	960	return d.CurrentCell.RowNumber == ItemProvider.Index
		961	&& d.CurrentCell.ColumnNumber == ItemProvider.GetColumnIndexOf (this);
		962	});
936	else if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)	963	else if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)
937	return ItemProvider.DataGridProvider.DataGrid.Enabled;	964	return ItemProvider.DataGridProvider.DataGrid.InvokeSync (d => d.Enabled);
938	else if (propertyId == AutomationElementIdentifiers.NameProperty.Id)	965	else if (propertyId == AutomationElementIdentifiers.NameProperty.Id)
939	return provider.GetName (this);	966	return provider.GetName (this);
940	else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {	967	else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {
941	SD.Rectangle rectangle = provider.DataGridProvider.DataGrid.GetCellBounds (provider.Index,	968	SD.Rectangle rectangle = provider.DataGridProvider.DataGrid.InvokeSync (d => d.GetCellBounds (provider.Index,
942	provider.GetColumnIndexOf (this));	969	provider.GetColumnIndexOf (this)));
943	Rect rect = Helper.GetControlScreenBounds (rectangle,	970	Rect rect = Helper.GetControlScreenBounds (rectangle,
944	provider.DataGridProvider.DataGrid,	971	provider.DataGridProvider.DataGrid,
945	true);	972	true);




				return;

			DataGridDataItemProvider dataItem = (DataGridDataItemProvider) item;
			datagridview.InvokeSync (delegate {
				datagridview.FirstDisplayedCell = dataItem.Row.Cells [0];
			});
		}

		public override IRawElementProviderSimple[] GetSelectedItems ()
		{
			List<DataGridViewDataItemChildProvider> items = new List<DataGridViewDataItemChildProvider> ();
			
			foreach (SWF.DataGridViewCell cell 
			         in datagridview.InvokeSync (d => d.SelectedCells)) {
				DataGridDataItemProvider itemProvider
					= (DataGridDataItemProvider) GetItemProviderFrom (this,
					                                                  datagridview.InvokeSync (d => d.Rows [cell.RowIndex]),
					                                                  false);
				if (itemProvider == null) //Not yet initialized
					break;

		}
		
		public override int SelectedItemsCount {
			get { return datagridview.InvokeSync (d => d.SelectedRows.Count); }
		}

		public override bool IsItemSelected (ListItemProvider item)

		}
		
		public override int ItemsCount {
			get { return datagridview.InvokeSync (c => c.Rows.Count); }
		}

		public override int IndexOfObjectItem (object objectItem)

			if (row == null)
				return -1;

			return datagridview.InvokeSync (c => c.Rows.IndexOf (row));
		}

		public override void FocusItem (object objectItem)
		{
			SWF.DataGridViewRow row = objectItem as SWF.DataGridViewRow;
			if (row == null || datagridview.InvokeSync (c => !c.Rows.Contains (row)))
				return;

			datagridview.InvokeSync (delegate { datagridview.CurrentCell = row.Cells [0]; });
		}

		public override object GetItemPropertyValue (ListItemProvider item, int propertyId)

			if (propertyId == AutomationElementIdentifiers.NameProperty.Id)
				return provider.Row.Cells [0].Value as string;
			else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)
				return datagridview.InvokeSync (c => c.CurrentCell == provider.Row.Cells [0] 
				                                && c.Focused);
			else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {
				return datagridview.InvokeSync (c => {
					SD.Rectangle rectangle = c.GetRowDisplayRectangle (provider.Row.Index, false);
					if (c.RowHeadersVisible)
						rectangle.X += c.RowHeadersWidth;
	
					return Helper.GetControlScreenBounds (rectangle, 
					                                      c,
					                                      true);					
				});
			} else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id)
				return Helper.IsListItemOffScreen (item.BoundingRectangle,
				                                   datagridview, 
				                                   datagridview.InvokeSync (d => d.ColumnHeadersVisible),
				                                   header.Size,
				                                   ScrollBehaviorObserver);
			else if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)

			AddChildProvider (header);

			datagridview.Rows.CollectionChanged += OnCollectionChanged;
			foreach (SWF.DataGridViewRow row 
			         in datagridview.InvokeSync (d => d.Rows)) {
				ListItemProvider itemProvider = GetItemProviderFrom (this, row);
				AddChildProvider (itemProvider);
			}


			public SD.Rectangle Size {
				get {
					return DataGridView.InvokeSync (d => {
						if (!d.ColumnHeadersVisible)
							return new SD.Rectangle (0, 0, 0, 0);
						else {
							SD.Rectangle bounds = SD.Rectangle.Empty;
							bounds.Height = d.ColumnHeadersHeight;
							bounds.Width = d.RowHeadersWidth;
							for (int index = 0; index < d.Columns.Count; index++)
								bounds.Width += d.Columns [index].Width;
							
							return bounds;
						}
					});
				}
			}


			{
				DataGridView.Columns.CollectionChanged += OnColumnsCollectionChanged;
				
				foreach (SWF.DataGridViewColumn column 
				         in DataGridView.InvokeSync (d => d.Columns))
					UpdateCollection (column, CollectionChangeAction.Add);
			}


				else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {
					if (column == null || column.Index < 0)
						return Rect.Empty;

					Rect headerBounds
						= (Rect) headerProvider.GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id);
					for (int index = 0; index < column.Index; index++)
						headerBounds.X += headerProvider.DataGridView.Columns [index].Width;

					headerBounds.X += headerProvider.DataGridView.RowHeadersWidth;
					headerBounds.Width = headerProvider.DataGridView.Columns [column.Index].Width;
					
					return headerProvider.DataGridView.InvokeSync (d => {
						Rect headerBounds
							= (Rect) headerProvider.GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id);
						for (int index = 0; index < column.Index; index++)
							headerBounds.X += d.Columns [index].Width;
	
						headerBounds.X += d.RowHeadersWidth;
						headerBounds.Width = d.Columns [column.Index].Width;
						
						return headerBounds;
					});
				} else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id) {
					Rect bounds 
						= (Rect) GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id);


			public override IRawElementProviderFragment GetFocus ()
			{
				return DataGridView.InvokeSync (d => {
					if (d.CurrentCell == null 
					    || d.CurrentCell.RowIndex != Row.Index)
				else {
					if (DataGridView.CurrentCell.ColumnIndex < 0 
					    || DataGridView.CurrentCell.ColumnIndex >= DataGridView.Columns.Count)
						return null;
					else {
						if (d.CurrentCell.ColumnIndex < 0 
						    || d.CurrentCell.ColumnIndex >= d.Columns.Count)
							return null;
	
						DataGridViewDataItemChildProvider provider = null;
						columns.TryGetValue (d.Columns [d.CurrentCell.ColumnIndex], 
						                     out provider);
						return provider;
				}
				});
			}

			public DataGridViewDataItemChildProvider GetChildItem (SWF.DataGridViewColumn column)

				if (columnIndex < 0 || columnIndex >= columns.Count)
					return null;

				return GetChildItem (datagridview.InvokeSync (d => d.Columns [columnIndex]));
			}

			protected override object GetProviderPropertyValue (int propertyId)


			public override void SetFocus ()
			{
				itemProvider.DataGridView.InvokeSync (delegate {
					itemProvider.DataGridView.Focus ();
					itemProvider.DataGridView.CurrentCell = cell;
				});
			}

			public override void Initialize ()

				if (propertyId == AutomationElementIdentifiers.NameProperty.Id)
					return cell.Value as string;
				else if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)
					return gridProvider.DataGridView.InvokeSync (d => d.Enabled);
				else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)
					return gridProvider.DataGridView.InvokeSync (d => d.CurrentCell == cell && d.Focused);
				else if (propertyId == AutomationElementIdentifiers.IsEnabledProperty.Id)
					return !Cell.ReadOnly;
				else if (propertyId == AutomationElementIdentifiers.LabeledByProperty.Id)

				else if (propertyId == AutomationElementIdentifiers.HelpTextProperty.Id)
					return cell.ToolTipText;
				else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {
					return itemProvider.DataGridView.InvokeSync (d => {
						Rect itemBounds = itemProvider.BoundingRectangle;
	
						for (int index = 0; index < cell.ColumnIndex; index++)
							itemBounds.X += d.Columns [index].Width;
	
						itemBounds.Width = d.Columns [cell.ColumnIndex].Width;
	
						return itemBounds;
					});
				} else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id)
					return cell.Displayed;
				else if (propertyId == AutomationElementIdentifiers.ClickablePointProperty.Id)

			{
				if (!ContainsItem (item))
					return;
				
				comboboxProvider.ComboBoxCell.DataGridView.InvokeSync (delegate {
					SWF.DataGridViewCell oldCell = comboboxProvider.ComboBoxCell.DataGridView.CurrentCell;
					comboboxProvider.ComboBoxCell.DataGridView.CurrentCell = comboboxProvider.ComboBoxCell;
					comboboxProvider.ComboBoxCell.Value = GetValueMemberFromValue (item.ObjectItem);
					comboboxProvider.ComboBoxCell.DataGridView.CurrentCell = oldCell;
				});
			}
			
			public override void UnselectItem (ListItemProvider item)
			{
				comboboxProvider.ComboBoxCell.DataGridView.InvokeSync (delegate {
					comboboxProvider.ComboBoxCell.Value = null;
				});
			}

			public override int IndexOfObjectItem (object objectItem)

				else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id)
					return comboboxProvider.GetPropertyValue (propertyId);
				else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)
					return comboboxProvider.ComboBoxCell.DataGridView.InvokeSync (d => d.Focused
					                                                              && d.CurrentCell == comboboxProvider.ComboBoxCell);
				else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id)
					// What when combobox is visible and scroll is hiden cell?
					return IsItemSelected (item);

Lines 101-107 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/DateTimePickerProvider.cs (-38 / +36 lines)
101	#region Private Methods	101	#region Private Methods
102	private void UpdateChildren ()	102	private void UpdateChildren ()
103	{	103	{
104	if (control.ShowCheckBox) {	104	if (control.InvokeSync (b => b.ShowCheckBox)) {
105	if (checkBox == null) {	105	if (checkBox == null) {
106	checkBox = new DateTimePickerCheckBoxProvider (this);	106	checkBox = new DateTimePickerCheckBoxProvider (this);
107	InsertChildProvider (checkBox, 0);	107	InsertChildProvider (checkBox, 0);
Lines 114-120 namespace Mono.UIAutomation.Winforms Link Here
114	}	114	}
115	}	115	}
116		116
117	if (control.ShowUpDown) {	117	if (control.InvokeSync (b => b.ShowUpDown)) {
118	if (dropDownButton != null) {	118	if (dropDownButton != null) {
119	RemoveChildProvider (dropDownButton);	119	RemoveChildProvider (dropDownButton);
120	dropDownButton.Terminate ();	120	dropDownButton.Terminate ();
Lines 131-138 namespace Mono.UIAutomation.Winforms Link Here
131		131
132	private void AddSegmentItems ()	132	private void AddSegmentItems ()
133	{	133	{
134	for (int i = 0; i < control.part_data.Length; i++) {	134	DateTimePicker.PartData []array
135	DateTimePicker.PartData part_data = control.part_data [i];	135	= control.InvokeSync (p => p.part_data);
		136
		137	for (int i = 0; i < array.Length; i++) {
		138	DateTimePicker.PartData part_data = array [i];
136	FragmentControlProvider prov = null;	139	FragmentControlProvider prov = null;
137		140
138	switch (part_data.date_time_part) {	141	switch (part_data.date_time_part) {
Lines 205-213 namespace Mono.UIAutomation.Winforms Link Here
205		208
206	SetBehavior (TogglePatternIdentifiers.Pattern,	209	SetBehavior (TogglePatternIdentifiers.Pattern,
207	new ToggleProviderBehavior (this));	210	new ToggleProviderBehavior (this));
208
209	SetEvent (ProviderEventType.AutomationElementHasKeyboardFocusProperty,
210	new CheckboxAutomationHasKeyboardFocusPropertyEvent (this));
211	}	211	}
212		212
213	public override IRawElementProviderFragmentRoot FragmentRoot {	213	public override IRawElementProviderFragmentRoot FragmentRoot {
Lines 221-230 namespace Mono.UIAutomation.Winforms Link Here
221	else if (propertyId == AEIds.IsContentElementProperty.Id)	221	else if (propertyId == AEIds.IsContentElementProperty.Id)
222	return false;	222	return false;
223	else if (propertyId == AEIds.IsKeyboardFocusableProperty.Id)	223	else if (propertyId == AEIds.IsKeyboardFocusableProperty.Id)
224	return true;	224	return false;
225	else if (propertyId == AEIds.HasKeyboardFocusProperty.Id)
226	return (bool) rootProvider.GetPropertyValue (AEIds.HasKeyboardFocusProperty.Id)
227	&& ((DateTimePicker) rootProvider.Control).UIAIsCheckBoxSelected;
228	else if (propertyId == AEIds.ControlTypeProperty.Id)	225	else if (propertyId == AEIds.ControlTypeProperty.Id)
229	return ControlType.CheckBox.Id;	226	return ControlType.CheckBox.Id;
230	else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)	227	else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)
Lines 294-300 namespace Mono.UIAutomation.Winforms Link Here
294	}	291	}
295		292
296	public string Text {	293	public string Text {
297	get { return PartData.GetText (((DateTimePicker) rootProvider.Control).Value); }	294	get {
		295	DateTime time = ((DateTimePicker) rootProvider.Control).InvokeSync (c => c.Value);
		296	return PartData.GetText (time);
		297	}
298	}	298	}
299		299
300	public override void Initialize ()	300	public override void Initialize ()
Lines 305-315 namespace Mono.UIAutomation.Winforms Link Here
305	new Events.DateTimePicker.AutomationNamePropertyEvent (	305	new Events.DateTimePicker.AutomationNamePropertyEvent (
306	this, rootProvider));	306	this, rootProvider));
307		307
308	SetEvent (ProviderEventType.AutomationElementIsEnabledProperty,	308	SetEvent (ProviderEventType.AutomationElementNameProperty,
309	new PartAutomationIsEnabledPropertyEvent (this));	309	new PartAutomationIsEnabledPropertyEvent (this));
310
311	SetEvent (ProviderEventType.AutomationElementHasKeyboardFocusProperty,
312	new PartAutomationHasKeyboardFocusPropertyEvent (this));
313	}	310	}
314		311
315	protected override object GetProviderPropertyValue (int propertyId)	312	protected override object GetProviderPropertyValue (int propertyId)
Lines 328-335 namespace Mono.UIAutomation.Winforms Link Here
328	return Catalog.GetString ("text");	325	return Catalog.GetString ("text");
329	else if (propertyId == AEIds.IsEnabledProperty.Id) {	326	else if (propertyId == AEIds.IsEnabledProperty.Id) {
330	DateTimePicker picker = (DateTimePicker) Control;	327	DateTimePicker picker = (DateTimePicker) Control;
331	return Control.Enabled	328	return picker.InvokeSync (c => c.Enabled
332	&& !(picker.ShowCheckBox && !picker.Checked);	329	&& !(c.ShowCheckBox && !c.Checked));
333	}	330	}
334	return base.GetProviderPropertyValue (propertyId);	331	return base.GetProviderPropertyValue (propertyId);
335	}	332	}
Lines 362-371 namespace Mono.UIAutomation.Winforms Link Here
362		359
363	public override void SetFocus ()	360	public override void SetFocus ()
364	{	361	{
365	if (dateTimePicker.ShowCheckBox && !dateTimePicker.Checked)	362	dateTimePicker.InvokeSync (delegate {
366	return;	363	if (dateTimePicker.ShowCheckBox && !dateTimePicker.Checked)
367		364	return;
368	dateTimePicker.SelectPart (part_index);	365
		366	dateTimePicker.SelectPart (part_index);
		367	});
369	}	368	}
370		369
371	protected override object GetProviderPropertyValue (int propertyId)	370	protected override object GetProviderPropertyValue (int propertyId)
Lines 373-380 namespace Mono.UIAutomation.Winforms Link Here
373	if (propertyId == AEIds.IsKeyboardFocusableProperty.Id)	372	if (propertyId == AEIds.IsKeyboardFocusableProperty.Id)
374	return true;	373	return true;
375	else if (propertyId == AEIds.HasKeyboardFocusProperty.Id)	374	else if (propertyId == AEIds.HasKeyboardFocusProperty.Id)
376	return (bool) rootProvider.GetPropertyValue (AEIds.HasKeyboardFocusProperty.Id)	375	return part_data.Selected;
377	&& part_data.Selected;
378	else if (propertyId == AEIds.ControlTypeProperty.Id)	376	else if (propertyId == AEIds.ControlTypeProperty.Id)
379	return ControlType.Spinner.Id;	377	return ControlType.Spinner.Id;
380	else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)	378	else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)
Lines 404-413 namespace Mono.UIAutomation.Winforms Link Here
404		402
405	public override void SetFocus ()	403	public override void SetFocus ()
406	{	404	{
407	if (dateTimePicker.ShowCheckBox && !dateTimePicker.Checked)	405	dateTimePicker.InvokeSync (delegate {
408	return;	406	if (dateTimePicker.ShowCheckBox && !dateTimePicker.Checked)
409		407	return;
410	((DateTimePicker) rootProvider.Control).SelectPart (part_index);	408
		409	((DateTimePicker) rootProvider.Control).SelectPart (part_index);
		410	});
411	}	411	}
412		412
413	public override void InitializeChildControlStructure ()	413	public override void InitializeChildControlStructure ()
Lines 415-421 namespace Mono.UIAutomation.Winforms Link Here
415	base.InitializeChildControlStructure ();	415	base.InitializeChildControlStructure ();
416		416
417	Calendar cal = Thread.CurrentThread.CurrentCulture.Calendar;	417	Calendar cal = Thread.CurrentThread.CurrentCulture.Calendar;
418	DateTime cur = dateTimePicker.Value;	418	DateTime cur = dateTimePicker.InvokeSync (d => d.Value);
419		419
420	switch (part_data.date_time_part) {	420	switch (part_data.date_time_part) {
421	case DateTimePicker.DateTimePart.Month:	421	case DateTimePicker.DateTimePart.Month:
Lines 483-490 namespace Mono.UIAutomation.Winforms Link Here
483	if (propertyId == AEIds.NameProperty.Id)	483	if (propertyId == AEIds.NameProperty.Id)
484	return itemProv.Text;	484	return itemProv.Text;
485	else if (propertyId == AEIds.HasKeyboardFocusProperty.Id)	485	else if (propertyId == AEIds.HasKeyboardFocusProperty.Id)
486	return (bool) rootProvider.GetPropertyValue (AEIds.HasKeyboardFocusProperty.Id)	486	return IsItemSelected (prov);
487	&& IsItemSelected (prov);
488	else if (propertyId == AEIds.BoundingRectangleProperty.Id)	487	else if (propertyId == AEIds.BoundingRectangleProperty.Id)
489	return GetProviderPropertyValue (AEIds.BoundingRectangleProperty.Id);	488	return GetProviderPropertyValue (AEIds.BoundingRectangleProperty.Id);
490	return null;	489	return null;
Lines 503-509 namespace Mono.UIAutomation.Winforms Link Here
503	public bool IsItemSelected (ListItemProvider prov)	502	public bool IsItemSelected (ListItemProvider prov)
504	{	503	{
505	Calendar cal = Thread.CurrentThread.CurrentCulture.Calendar;	504	Calendar cal = Thread.CurrentThread.CurrentCulture.Calendar;
506	DateTime cur = dateTimePicker.Value;	505	DateTime cur = dateTimePicker.InvokeSync (d => d.Value);
507	DateTime date = (DateTime) prov.ObjectItem;	506	DateTime date = (DateTime) prov.ObjectItem;
508		507
509	switch (part_data.date_time_part) {	508	switch (part_data.date_time_part) {
Lines 525-534 namespace Mono.UIAutomation.Winforms Link Here
525		524
526	public void SelectItem (ListItemProvider prov)	525	public void SelectItem (ListItemProvider prov)
527	{	526	{
528	if (dateTimePicker.ShowCheckBox && !dateTimePicker.Checked)	527	if (dateTimePicker.InvokeSync (d => d.ShowCheckBox && !d.Checked))
529	return;	528	return;
530		529
531	DateTime cur = dateTimePicker.Value;	530	DateTime cur = dateTimePicker.InvokeSync (d => d.Value);
532	Calendar cal = Thread.CurrentThread.CurrentCulture.Calendar;	531	Calendar cal = Thread.CurrentThread.CurrentCulture.Calendar;
533	DateTime date = (DateTime) prov.ObjectItem;	532	DateTime date = (DateTime) prov.ObjectItem;
534		533
Lines 538-544 namespace Mono.UIAutomation.Winforms Link Here
538	break;	537	break;
539	case DateTimePicker.DateTimePart.DayName:	538	case DateTimePicker.DateTimePart.DayName:
540	cur = cur.AddDays (cal.GetDayOfWeek (date)	539	cur = cur.AddDays (cal.GetDayOfWeek (date)
541	- cal.GetDayOfWeek (dateTimePicker.Value));	540	- cal.GetDayOfWeek (cur));
542	break;	541	break;
543	case DateTimePicker.DateTimePart.AMPMSpecifier:	542	case DateTimePicker.DateTimePart.AMPMSpecifier:
544	if (date == amDate && IsTimePM (cur)) {	543	if (date == amDate && IsTimePM (cur)) {
Lines 563-569 namespace Mono.UIAutomation.Winforms Link Here
563		562
564	public ListItemProvider GetSelectedItem ()	563	public ListItemProvider GetSelectedItem ()
565	{	564	{
566	DateTime cur = dateTimePicker.Value;	565	DateTime cur = dateTimePicker.InvokeSync (d => d.Value);
567	Calendar cal = Thread.CurrentThread.CurrentCulture.Calendar;	566	Calendar cal = Thread.CurrentThread.CurrentCulture.Calendar;
568	DateTime searchDate = DateTime.MinValue;	567	DateTime searchDate = DateTime.MinValue;
569		568
Lines 591-598 namespace Mono.UIAutomation.Winforms Link Here
591	if (propertyId == AEIds.IsKeyboardFocusableProperty.Id)	590	if (propertyId == AEIds.IsKeyboardFocusableProperty.Id)
592	return true;	591	return true;
593	else if (propertyId == AEIds.HasKeyboardFocusProperty.Id)	592	else if (propertyId == AEIds.HasKeyboardFocusProperty.Id)
594	return (bool) rootProvider.GetPropertyValue (AEIds.HasKeyboardFocusProperty.Id)	593	return part_data.Selected;
595	&& part_data.Selected;
596	else if (propertyId == AEIds.NameProperty.Id)	594	else if (propertyId == AEIds.NameProperty.Id)
597	return Text;	595	return Text;
598	else if (propertyId == AEIds.ControlTypeProperty.Id)	596	else if (propertyId == AEIds.ControlTypeProperty.Id)

Lines 76-82 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/DomainUpDownProvider.cs (-5 / +9 lines)
76		76
77	public void FocusItem (object objectItem)	77	public void FocusItem (object objectItem)
78	{	78	{
79	control.SelectedItem = objectItem;	79	control.InvokeSync (delegate {
		80	control.SelectedItem = objectItem;
		81	});
80	}	82	}
81	#endregion	83	#endregion
82		84
Lines 106-112 namespace Mono.UIAutomation.Winforms Link Here
106	#region IListProvider Implementation	108	#region IListProvider Implementation
107	public int IndexOfObjectItem (object obj)	109	public int IndexOfObjectItem (object obj)
108	{	110	{
109	return control.Items.IndexOf (obj);	111	return control.InvokeSync (c => c.Items.IndexOf (obj));
110	}	112	}
111		113
112	public IProviderBehavior GetListItemBehaviorRealization (AutomationPattern pattern,	114	public IProviderBehavior GetListItemBehaviorRealization (AutomationPattern pattern,
Lines 135-141 namespace Mono.UIAutomation.Winforms Link Here
135	if (propertyId == AEIds.NameProperty.Id) {	137	if (propertyId == AEIds.NameProperty.Id) {
136	return (string)prov.ObjectItem;	138	return (string)prov.ObjectItem;
137	} else if (propertyId == AEIds.HasKeyboardFocusProperty.Id) {	139	} else if (propertyId == AEIds.HasKeyboardFocusProperty.Id) {
138	return IsItemSelected (prov) && (string)prov.ObjectItem == Control.Text;	140	return IsItemSelected (prov)
		141	&& control.InvokeSync (c => (string) prov.ObjectItem == c.Text);
139	} else if (propertyId == AEIds.BoundingRectangleProperty.Id) {	142	} else if (propertyId == AEIds.BoundingRectangleProperty.Id) {
140	return GetProviderPropertyValue (AEIds.BoundingRectangleProperty.Id);	143	return GetProviderPropertyValue (AEIds.BoundingRectangleProperty.Id);
141	}	144	}
Lines 154-165 namespace Mono.UIAutomation.Winforms Link Here
154		157
155	public bool IsItemSelected (ListItemProvider prov)	158	public bool IsItemSelected (ListItemProvider prov)
156	{	159	{
157	int index = control.Items.IndexOf (prov.ObjectItem);	160	int index
		161	= control.InvokeSync (c => c.Items.IndexOf (prov.ObjectItem));
158	if (index < 0) {	162	if (index < 0) {
159	return false;	163	return false;
160	}	164	}
161		165
162	return (index == control.SelectedIndex);	166	return control.InvokeSync (c => index == c.SelectedIndex);
163	}	167	}
164		168
165	public int SelectedItemsCount {	169	public int SelectedItemsCount {

Lines 71-76 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/FormListener.cs (-1 / +3 lines)
71	Application.FormAdded += new EventHandler (OnFormAdded);	71	Application.FormAdded += new EventHandler (OnFormAdded);
72		72
73	initialized = true;	73	initialized = true;
		74
		75	System.Threading.Thread.CurrentThread.Name = "UIA-Winforms";
74	}	76	}
75		77
76	#endregion	78	#endregion
Lines 101-107 namespace Mono.UIAutomation.Winforms Link Here
101	//Initialize navigation to let children use it	103	//Initialize navigation to let children use it
102	provider.Navigation = NavigationFactory.CreateNavigation (provider);	104	provider.Navigation = NavigationFactory.CreateNavigation (provider);
103	provider.Navigation.Initialize ();	105	provider.Navigation.Initialize ();
104		106
105	// TODO: Fill in rest of eventargs	107	// TODO: Fill in rest of eventargs
106	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildAdded,	108	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildAdded,
107	provider);	109	provider);




			
			// We keep a copy because we can't reference "form" after 
			// Disposed (used in Close()) called by WindowPatternWindowClosedEvent.
			owner = form.InvokeSync (c => c.Owner);
			alreadyClosed = false;
		}
		

		
		public override IRawElementProviderFragment ElementProviderFromPoint (double x, double y)
		{
			if (form.InvokeSync (c => x > c.Width || y > c.Height))
				return null;
			
			Control child 
				= form.InvokeSync (c => c.GetChildAtPoint (new Point ((int) x, (int) y)));
			
			if (child != null) {
				Log.Debug (child.ToString ());

		
		public override IRawElementProviderFragment GetFocus ()
		{
			foreach (Control control in form.InvokeSync (f => f.Controls)) {
				if (control.InvokeSync (c => c.Focused)) {
					// TODO: Necessary to delve into child control
					// for focused element?
					

			if (AutomationInteropProvider.ClientsAreListening && !AlreadyClosed) {
				alreadyClosed = true;

				if (owner == null) {
					Helper.RaiseStructureChangedEvent (StructureChangeType.ChildRemoved,
					                                   this);
				} else {
					FormProvider ownerProvider 
						= ProviderFactory.FindProvider (owner) as FormProvider;
					if (ownerProvider != null)


		private void SetupMainMenuProvider ()
		{
			MainMenu mainMenu = form.InvokeSync (f => f.Menu);
			
			if (mainMenu != null) {
				mainMenuProvider = (MainMenuProvider)
					ProviderFactory.GetProvider (mainMenu);
				if (mainMenuProvider != null)
					AddChildProvider (mainMenuProvider);
			}




				HandleContextMenuChanged (null, EventArgs.Empty);
				HandleContextMenuStripChanged (null, EventArgs.Empty);

				visible = Control.InvokeSync (c => c.Visible);
			}
		}


				contextMenuStrip.Opened -= HandleContextMenuStripOpened;
				contextMenuStrip.Closed -= HandleContextMenuStripClosed;
			}
			contextMenuStrip = Control.InvokeSync (c => c.ContextMenuStrip);

			if (contextMenuStrip != null) {
				contextMenuStrip.Opened += HandleContextMenuStripOpened;

				contextMenu.Popup -= HandleContextMenuPopup;
				contextMenu.Collapse -= HandleContextMenuCollapse;
			}
			contextMenu = Control.InvokeSync (c => c.ContextMenu);

			if (contextMenu != null) {
				contextMenu.Popup += HandleContextMenuPopup;

			RemoveChildProvider (true, childProvider);
		}

		public override void Initialize ()
		{
			base.Initialize ();

			if (Control != null) {
				Control.ContextMenuChanged += HandleContextMenuChanged;
				Control.ContextMenuStripChanged += HandleContextMenuStripChanged;

				HandleContextMenuChanged (null, EventArgs.Empty);
				HandleContextMenuStripChanged (null, EventArgs.Empty);

				visible = Control.InvokeSync (c => c.Visible);
			}
		}

		public override void Terminate ()
		{
			base.Terminate ();

				Control.ControlAdded += OnControlAdded;
				Control.ControlRemoved += OnControlRemoved;
				
				foreach (SWF.Control childControl in Control.InvokeSync (c => c.Controls))
					HandleComponentAdded (childControl);

				Control.VisibleChanged += OnControlVisibleChanged;

		
		private void OnControlVisibleChanged (object sender, EventArgs args)
		{
			bool isVisible = Control.InvokeSync (c => c.Visible);
			
			if (visible == isVisible)
				return;

			if (isVisible)
				InitializeChildControlStructure ();
			else
				FinalizeChildControlStructure ();

			visible = isVisible;
		}

		private void OnChildControlVisibleChanged (object sender, EventArgs args)

		{
			SWF.Control control = null;
			if ((control = component as SWF.Control) != null)
				return control.InvokeSync (c => c.Visible);
			else // Component based providers will need to override this method
				return false;
		}

		public virtual void SetFocus ()
		{
			if (Control != null)
				Control.InvokeSync (delegate { Control.Focus (); });
		}

		#endregion

Lines 17-23 Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/Helper.cs (-29 / +90 lines)
17	// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION	17	// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
18	// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.	18	// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19	//	19	//
20	// Copyright (c) 2008 Novell, Inc. (http://www.novell.com)	20	// Copyright (c) 2008,2009 Novell, Inc. (http://www.novell.com)
21	//	21	//
22	// Authors:	22	// Authors:
23	// Mario Carrion <mcarrion@novell.com>	23	// Mario Carrion <mcarrion@novell.com>
Lines 27-36 using System; Link Here
27	using System.Drawing;	27	using System.Drawing;
28	using System.Reflection;	28	using System.Reflection;
29	using System.Windows;	29	using System.Windows;
		30	using System.ComponentModel;
30	using SWF = System.Windows.Forms;	31	using SWF = System.Windows.Forms;
31	using System.Windows.Automation;	32	using System.Windows.Automation;
32	using System.Windows.Automation.Provider;	33	using System.Windows.Automation.Provider;
33		34
		35	using System.Threading;
		36
34	namespace Mono.UIAutomation.Winforms	37	namespace Mono.UIAutomation.Winforms
35	{	38	{
36		39
Lines 68-85 namespace Mono.UIAutomation.Winforms Link Here
68		71
69	internal static Rect GetControlScreenBounds (Rectangle bounds, SWF.Control control, bool controlIsParent)	72	internal static Rect GetControlScreenBounds (Rectangle bounds, SWF.Control control, bool controlIsParent)
70	{	73	{
71	if (control == null \|\| !control.Visible)	74	if (control == null)
72	return Rect.Empty;	75	return Rect.Empty;
73	else if (controlIsParent)
74	return Helper.RectangleToRect (control.RectangleToScreen (bounds));
75	else if (control.Parent == null \|\| control.TopLevelControl == null)
76	return Helper.RectangleToRect (bounds);
77	else {	76	else {
78		77	return control.InvokeSync (c => {
79	if (control.FindForm () == control.Parent)	78	if (!c.Visible)
80	return Helper.RectangleToRect (control.TopLevelControl.RectangleToScreen (bounds));	79	return Rect.Empty;
81	else	80	else if (controlIsParent)
82	return Helper.RectangleToRect (control.Parent.RectangleToScreen (bounds));	81	return Helper.RectangleToRect (c.RectangleToScreen (bounds));
		82	else if (c.Parent == null \|\| c.TopLevelControl == null)
		83	return Helper.RectangleToRect (bounds);
		84	else {
		85	if (c.FindForm () == c.Parent)
		86	return Helper.RectangleToRect (c.TopLevelControl.RectangleToScreen (bounds));
		87	else
		88	return Helper.RectangleToRect (c.Parent.RectangleToScreen (bounds));
		89	}
		90	});
83	}	91	}
84	}	92	}
85		93
Lines 93-99 namespace Mono.UIAutomation.Winforms Link Here
93	if (item.Owner == null)	101	if (item.Owner == null)
94	return item.Bounds;	102	return item.Bounds;
95	else	103	else
96	return item.Owner.RectangleToScreen (item.Bounds);	104	return item.Owner.InvokeSync (c => c.RectangleToScreen (item.Bounds));
97	}	105	}
98		106
99	internal static object GetClickablePoint (SimpleControlProvider provider)	107	internal static object GetClickablePoint (SimpleControlProvider provider)
Lines 131-141 namespace Mono.UIAutomation.Winforms Link Here
131	else	139	else
132	screen = Helper.RectangleToRect (SWF.Screen.GetWorkingArea (referenceControl));	140	screen = Helper.RectangleToRect (SWF.Screen.GetWorkingArea (referenceControl));
133		141
134	IRawElementProviderFragment formProvider = null;	142	// SWF.Form form = Helper.SynchronizedGet<SWF.Control, SWF.Form> (referenceControl, v => referenceControl.FindForm ());
135	if ((formProvider = ProviderFactory.FindProvider (referenceControl.FindForm ())) != null)	143
136	return !formProvider.BoundingRectangle.IntersectsWith (bounds) \|\| !bounds.IntersectsWith (screen);	144	// return Helper.SynchronizedGet<SWF.Control, bool> (referenceControl, v => {
137		145	IRawElementProviderFragment formProvider = null;
138	return !bounds.IntersectsWith (screen);	146	// Console.WriteLine (">>referenceControl: {0}", referenceControl == null);
		147	// if ((formProvider = ProviderFactory.FindProvider (form)) != null)
		148	if ((formProvider = ProviderFactory.FindProvider (referenceControl.FindForm ())) != null)
		149	return !formProvider.BoundingRectangle.IntersectsWith (bounds) \|\| !bounds.IntersectsWith (screen);
		150
		151	return !bounds.IntersectsWith (screen);
		152	// });
139	}	153	}
140		154
141	internal static bool IsListItemOffScreen (Rect itemBounds,	155	internal static bool IsListItemOffScreen (Rect itemBounds,
Lines 144-150 namespace Mono.UIAutomation.Winforms Link Here
144	Rectangle headerBounds,	158	Rectangle headerBounds,
145	IScrollBehaviorObserver observer)	159	IScrollBehaviorObserver observer)
146	{	160	{
147	Rectangle listViewRectangle = containerControl.Bounds;	161	Rectangle listViewRectangle = containerControl.InvokeSync (c => c.Bounds);
148	if (visibleHeader) {	162	if (visibleHeader) {
149	listViewRectangle.Y += headerBounds.Height;	163	listViewRectangle.Y += headerBounds.Height;
150	listViewRectangle.Height -= headerBounds.Height;	164	listViewRectangle.Height -= headerBounds.Height;
Lines 153-161 namespace Mono.UIAutomation.Winforms Link Here
153	listViewRectangle.Height -= observer.HorizontalScrollBar.Height;	167	listViewRectangle.Height -= observer.HorizontalScrollBar.Height;
154	if (observer.VerticalScrollBar.Visible)	168	if (observer.VerticalScrollBar.Visible)
155	listViewRectangle.Width -= observer.VerticalScrollBar.Width;	169	listViewRectangle.Width -= observer.VerticalScrollBar.Width;
156		170
157	Rect screen	171	SWF.Control parent = containerControl.InvokeSync (c => c.Parent);
158	= Helper.RectangleToRect (containerControl.Parent.RectangleToScreen (listViewRectangle));	172	Rect screen
		173	= parent.InvokeSync (c => Helper.RectangleToRect (c.RectangleToScreen (listViewRectangle)));
159	return !itemBounds.IntersectsWith (screen);	174	return !itemBounds.IntersectsWith (screen);
160	}	175	}
161		176
Lines 179-191 namespace Mono.UIAutomation.Winforms Link Here
179	int imageY;	194	int imageY;
180	int imageWidth;	195	int imageWidth;
181	int imageHeight;	196	int imageHeight;
182	int width = buttonBase.Width;	197	int width = buttonBase.InvokeSync (c => c.Width);
183	int height = buttonBase.Height;	198	int height = buttonBase.InvokeSync (c => c.Height);
184		199
185	if (buttonBase.ImageIndex != -1)	200	image = buttonBase.InvokeSync (c => {
186	image = buttonBase.ImageList.Images [buttonBase.ImageIndex];	201	if (c.ImageIndex != -1)
187	else	202	return c.ImageList.Images [c.ImageIndex];
188	image = buttonBase.Image;	203	else
		204	return c.Image;
		205	});
189		206
190	if (image == null)	207	if (image == null)
191	return Rect.Empty;	208	return Rect.Empty;
Lines 193-199 namespace Mono.UIAutomation.Winforms Link Here
193	imageWidth = image.Width;	210	imageWidth = image.Width;
194	imageHeight = image.Height;	211	imageHeight = image.Height;
195		212
196	switch (buttonBase.ImageAlign) {	213	switch (buttonBase.InvokeSync (c => c.ImageAlign)) {
197	case ContentAlignment.TopLeft: {	214	case ContentAlignment.TopLeft: {
198	imageX = 5;	215	imageX = 5;
199	imageY = 5;	216	imageY = 5;
Lines 379-385 namespace Mono.UIAutomation.Winforms Link Here
379	runtimeId = new int[] {0};	396	runtimeId = new int[] {0};
380	else	397	else
381	runtimeId = provider.GetRuntimeId ();	398	runtimeId = provider.GetRuntimeId ();
382		399
383	StructureChangedEventArgs invalidatedArgs	400	StructureChangedEventArgs invalidatedArgs
384	= new StructureChangedEventArgs (type, runtimeId);	401	= new StructureChangedEventArgs (type, runtimeId);
385	AutomationInteropProvider.RaiseStructureChangedEvent (provider,	402	AutomationInteropProvider.RaiseStructureChangedEvent (provider,
Lines 445-450 namespace Mono.UIAutomation.Winforms Link Here
445	s = s.Remove (i, 1);	462	s = s.Remove (i, 1);
446	return s;	463	return s;
447	}	464	}
		465
		466	internal static int Counter = 0;
		467
448	#endregion	468	#endregion
449		469
450	#region Private Static Methods	470	#region Private Static Methods
Lines 491-494 namespace Mono.UIAutomation.Winforms Link Here
491		511
492	#endregion	512	#endregion
493	}	513	}
		514
		515	internal static class InvokeRequiredExtensionControl
		516	{
		517	public static TResult InvokeSync<TControl, TResult> (this TControl control,
		518	Func<TControl, TResult> func)
		519	where TControl : SWF.Control
		520	{
		521	// This happens when a Winforms event raises an AutomationEvent
		522	// that raises an Atk event that needs to request Winforms data :-)
		523	if (AlreadyInvoked)
		524	return (TResult) func (control);
		525
		526	if (control.InvokeRequired && control.IsHandleCreated) {
		527	if (Interlocked.CompareExchange (ref alreadyInvoked, 1, 0) == 0) {
		528	TResult result = (TResult) control.Invoke (func, control);
		529	Interlocked.CompareExchange (ref alreadyInvoked, 0, 1);
		530	return result;
		531	} else
		532	return (TResult) func (control);
		533	} else
		534	return (TResult) func (control);
		535	}
		536
		537	public static void InvokeSync<TControl> (this TControl control,
		538	Action<TControl> action)
		539	where TControl : SWF.Control
		540	{
		541	// We don't care about AlreadyInvoked since we are not
		542	// returning a value.
		543	if (control.InvokeRequired && control.IsHandleCreated)
		544	control.BeginInvoke (action, control);
		545	else
		546	action (control);
		547	}
		548
		549	private static bool AlreadyInvoked {
		550	get { return Interlocked.CompareExchange (ref alreadyInvoked, 0, 0) == 1; }
		551	}
		552
		553	private static int alreadyInvoked = 0;
		554	}
494	}	555	}

Lines 56-66 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/ListBoxProvider.cs (-45 / +69 lines)
56	#region Scroll Methods and Properties	56	#region Scroll Methods and Properties
57		57
58	protected override ScrollBar HorizontalScrollBar {	58	protected override ScrollBar HorizontalScrollBar {
59	get { return listboxControl.UIAHScrollBar; }	59	get {
		60	return listboxControl.InvokeSync (c => c.UIAHScrollBar);
		61	}
60	}	62	}
61		63
62	protected override ScrollBar VerticalScrollBar {	64	protected override ScrollBar VerticalScrollBar {
63	get { return listboxControl.UIAVScrollBar; }	65	get {
		66	return listboxControl.InvokeSync (c => c.UIAVScrollBar);
		67	}
64	}	68	}
65		69
66	#endregion	70	#endregion
Lines 88-97 namespace Mono.UIAutomation.Winforms Link Here
88	else if (propertyId == AutomationElementIdentifiers.LocalizedControlTypeProperty.Id)	92	else if (propertyId == AutomationElementIdentifiers.LocalizedControlTypeProperty.Id)
89	return Catalog.GetString ("list");	93	return Catalog.GetString ("list");
90	else if (propertyId == AutomationElementIdentifiers.NameProperty.Id) {	94	else if (propertyId == AutomationElementIdentifiers.NameProperty.Id) {
91	if (string.IsNullOrEmpty (listboxControl.AccessibleName))	95	return listboxControl.InvokeSync (c => {
92	return Helper.StripAmpersands (listboxControl.Text);	96	if (string.IsNullOrEmpty (c.AccessibleName))
93	else	97	return Helper.StripAmpersands (c.Text);
94	return listboxControl.AccessibleName;	98	else
		99	return c.AccessibleName;
		100	});
95	} else	101	} else
96	return base.GetProviderPropertyValue (propertyId);	102	return base.GetProviderPropertyValue (propertyId);
97	}	103	}
Lines 113-143 namespace Mono.UIAutomation.Winforms Link Here
113		119
114	public override IRawElementProviderFragment GetFocus ()	120	public override IRawElementProviderFragment GetFocus ()
115	{	121	{
116	return GetItemProviderFrom (this, listboxControl.Items [listboxControl.FocusedItem]);	122	return listboxControl.InvokeSync (c => GetItemProviderFrom (this, c.Items [c.FocusedItem]));
117	}	123	}
118		124
119	public override void FocusItem (object objectItem)	125	public override void FocusItem (object objectItem)
120	{	126	{
121	listboxControl.FocusedItem = listboxControl.Items.IndexOf (objectItem);	127	listboxControl.InvokeSync (delegate {
		128	listboxControl.FocusedItem = listboxControl.Items.IndexOf (objectItem);
		129	});
122	}	130	}
123		131
124	public override void InitializeChildControlStructure ()	132	public override void InitializeChildControlStructure ()
125	{	133	{
126	base.InitializeChildControlStructure ();	134	base.InitializeChildControlStructure ();
127		135
128	listboxControl.Items.UIACollectionChanged += OnCollectionChanged;	136	listboxControl.InvokeSync (delegate {
129		137	listboxControl.Items.UIACollectionChanged += OnCollectionChanged;
130	foreach (object objectItem in listboxControl.Items) {	138
131	ListItemProvider item = GetItemProviderFrom (this, objectItem);	139	foreach (object objectItem in listboxControl.Items) {
132	AddChildProvider (item);	140	ListItemProvider item = GetItemProviderFrom (this, objectItem);
133	}	141	AddChildProvider (item);
		142	}
		143	});
134	}	144	}
135		145
136	public override void FinalizeChildControlStructure ()	146	public override void FinalizeChildControlStructure ()
137	{	147	{
138	base.FinalizeChildControlStructure ();	148	base.FinalizeChildControlStructure ();
139		149
140	listboxControl.Items.UIACollectionChanged -= OnCollectionChanged;	150	listboxControl.InvokeSync (delegate {
		151	listboxControl.Items.UIACollectionChanged -= OnCollectionChanged;
		152	});
141	}	153	}
142		154
143	#endregion	155	#endregion
Lines 148-174 namespace Mono.UIAutomation.Winforms Link Here
148	int propertyId)	160	int propertyId)
149	{	161	{
150	if (propertyId == AutomationElementIdentifiers.NameProperty.Id)	162	if (propertyId == AutomationElementIdentifiers.NameProperty.Id)
151	return listboxControl.GetItemText (item.ObjectItem);	163	return listboxControl.InvokeSync (s => s.GetItemText (item.ObjectItem));
152		164
153	if (ContainsItem (item) == false)	165	if (ContainsItem (item) == false)
154	return null;	166	return null;
155		167
156	if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)	168	if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)
157	return listboxControl.Focused && item.Index == listboxControl.FocusedItem;	169	return listboxControl.InvokeSync (s => s.Focused
		170	&& item.Index == s.FocusedItem);
158	else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {	171	else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {
159	System.Drawing.Rectangle itemRec = System.Drawing.Rectangle.Empty;	172	return listboxControl.InvokeSync (c => {
160	System.Drawing.Rectangle rectangle = listboxControl.Bounds;	173	System.Drawing.Rectangle itemRec = System.Drawing.Rectangle.Empty;
161		174	System.Drawing.Rectangle rectangle = c.Bounds;
162	itemRec = listboxControl.GetItemRectangle (item.Index);
163	itemRec.X += rectangle.X;
164	itemRec.Y += rectangle.Y;
165
166	if (listboxControl.FindForm () == listboxControl.Parent)
167	itemRec = listboxControl.TopLevelControl.RectangleToScreen (itemRec);
168	else
169	itemRec = listboxControl.Parent.RectangleToScreen (itemRec);
170		175
171	return Helper.RectangleToRect (itemRec);	176	itemRec = c.GetItemRectangle (item.Index);
		177	itemRec.X += rectangle.X;
		178	itemRec.Y += rectangle.Y;
		179
		180	if (c.FindForm () == c.Parent)
		181	itemRec = c.TopLevelControl.RectangleToScreen (itemRec);
		182	else
		183	itemRec = c.Parent.RectangleToScreen (itemRec);
		184
		185	return Helper.RectangleToRect (itemRec);
		186	});
172	} else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id)	187	} else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id)
173	return Helper.IsListItemOffScreen ((Rect) item.GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id),	188	return Helper.IsListItemOffScreen ((Rect) item.GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id),
174	listboxControl,	189	listboxControl,
Lines 183-228 namespace Mono.UIAutomation.Winforms Link Here
183		198
184	#region ListProvider: Specializations	199	#region ListProvider: Specializations
185		200
186	public override int SelectedItemsCount {	201	public override int SelectedItemsCount {
187	get { return listboxControl.SelectedItems.Count; }	202	get { return listboxControl.InvokeSync (c => c.SelectedItems.Count); }
188	}	203	}
189		204
190	public override int ItemsCount {	205	public override int ItemsCount {
191	get { return listboxControl.Items.Count; }	206	get { return listboxControl.InvokeSync (c => c.Items.Count); }
192	}	207	}
193		208
194	public override int IndexOfObjectItem (object objectItem)	209	public override int IndexOfObjectItem (object objectItem)
195	{	210	{
196	return listboxControl.Items.IndexOf (objectItem);	211	return listboxControl.InvokeSync (c => c.Items.IndexOf (objectItem));
197	}	212	}
198		213
199	public override IRawElementProviderSimple[] GetSelectedItems ()	214	public override IRawElementProviderSimple[] GetSelectedItems ()
200	{	215	{
201	ListItemProvider []items;	216	ListItemProvider []items;
202		217
203	if (listboxControl == null \|\| listboxControl.SelectedIndices.Count == 0)	218	if (listboxControl == null
		219	\|\| listboxControl.InvokeSync (c => c.SelectedIndices.Count == 0))
204	return new ListItemProvider [0];	220	return new ListItemProvider [0];
205		221
206	items = new ListItemProvider [listboxControl.SelectedIndices.Count];	222	return listboxControl.InvokeSync (c => {
207	for (int index = 0; index < items.Length; index++)	223	items = new ListItemProvider [c.SelectedIndices.Count];
208	items [index] = GetItemProviderFrom (this, listboxControl.Items [listboxControl.SelectedIndices [index]]);	224	for (int index = 0; index < items.Length; index++)
209		225	items [index] = GetItemProviderFrom (this, c.Items [c.SelectedIndices [index]]);
210	return items;	226
		227	return items;
		228	});
211	}	229	}
212		230
213	public override void SelectItem (ListItemProvider item)	231	public override void SelectItem (ListItemProvider item)
214	{	232	{
215	listboxControl.SetSelected (item.Index, true);	233	listboxControl.InvokeSync (delegate {
		234	listboxControl.SetSelected (item.Index, true);
		235	});
216	}	236	}
217		237
218	public override void UnselectItem (ListItemProvider item)	238	public override void UnselectItem (ListItemProvider item)
219	{	239	{
220	listboxControl.SetSelected (item.Index, false);	240	listboxControl.InvokeSync (delegate {
		241	listboxControl.SetSelected (item.Index, false);
		242	});
221	}	243	}
222		244
223	public override bool IsItemSelected (ListItemProvider item)	245	public override bool IsItemSelected (ListItemProvider item)
224	{	246	{
225	return listboxControl.SelectedIndices.Contains (item.Index);	247	return listboxControl.InvokeSync (b => b.SelectedIndices.Contains (item.Index));
226	}	248	}
227		249
228	public override IConnectable GetListItemEventRealization (ProviderEventType eventType,	250	public override IConnectable GetListItemEventRealization (ProviderEventType eventType,
Lines 241-247 namespace Mono.UIAutomation.Winforms Link Here
241	public override void ScrollItemIntoView (ListItemProvider item)	263	public override void ScrollItemIntoView (ListItemProvider item)
242	{	264	{
243	if (ContainsItem (item) == true)	265	if (ContainsItem (item) == true)
244	listboxControl.TopIndex = item.Index;	266	listboxControl.InvokeSync (delegate {
		267	listboxControl.TopIndex = item.Index;
		268	});
245	}	269	}
246		270
247	#endregion	271	#endregion




// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
// 
// Copyright (c) 2008,2009 Novell, Inc. (http://www.novell.com) 
// 
// Authors: 
//	Mario Carrion <mcarrion@novell.com>

		public ListViewProvider (SWF.ListView listView) : base (listView)
		{
			this.listView = listView;
			
			lastView = listView.InvokeSync (c => c.View);
			showGroups = listView.InvokeSync (c => c.ShowGroups);
			groups = new Dictionary<SWF.ListViewGroup, ListViewGroupProvider> ();
		}
		

		protected override object GetProviderPropertyValue (int propertyId)
		{
			if (propertyId == AutomationElementIdentifiers.ControlTypeProperty.Id) {
				if (listView.InvokeSync (c => c.View == SWF.View.Details))
					return ControlType.DataGrid.Id;
				else
					return ControlType.List.Id;
			} else if (propertyId == AutomationElementIdentifiers.LocalizedControlTypeProperty.Id) {
				if (listView.InvokeSync (c => c.View == SWF.View.Details))
					return Catalog.GetString ("data grid");
				else
					return Catalog.GetString ("list");

			else if (behavior == SelectionPatternIdentifiers.Pattern) 
				return new SelectionProviderBehavior (this);
			else if (behavior == GridPatternIdentifiers.Pattern) {
				if (listView.InvokeSync (c => !c.ShowGroups
				                         || !SWF.Application.VisualStylesEnabled
				                         || c.View == SWF.View.List
				                         || c.View == SWF.View.Details))
				    return new GridProviderBehavior (this);
				else
					return null;
			} else if (behavior == TablePatternIdentifiers.Pattern) {
				if (listView.InvokeSync (c => c.View == SWF.View.Details))
					return new TableProviderBehavior (this);
				else
					return null;

				return new ListItemSelectionItemProviderBehavior (listItem);
			else if (behavior == GridItemPatternIdentifiers.Pattern) {
				// LAMESPEC: GridItem implemented *only* when: listView.View != SWF.View.Details
				if (listView.InvokeSync (c => c.View != SWF.View.Details)
				    || IsBehaviorEnabled (GridPatternIdentifiers.Pattern))
					return new ListItemGridItemProviderBehavior (listItem);
				else
					return null;
			} else if (behavior == InvokePatternIdentifiers.Pattern && Control is SWF.MWFFileView) {
				return new ListItemInvokeProviderBehavior (listItem);
			} else if (behavior == ValuePatternIdentifiers.Pattern) {
				if (listView.InvokeSync (c => c.LabelEdit))
					return new ListItemValueProviderBehavior (listItem);
				else
					return null;
			} else if (behavior == TogglePatternIdentifiers.Pattern) {
				if (listView.InvokeSync (c => c.CheckBoxes))
					return new ListItemToggleProviderBehavior (listItem);
				else
					return null;
			} else if (behavior == TableItemPatternIdentifiers.Pattern) {
				if (listView.InvokeSync (c => c.View == SWF.View.Details))
					return new ListItemTableItemProviderBehavior (listItem);
				else
					return null;

			if (propertyId == AutomationElementIdentifiers.NameProperty.Id)
				return ((SWF.ListViewItem) item.ObjectItem).Text;
			else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)
				return listView.InvokeSync (c => c.Focused 
				                             && ((SWF.ListViewItem) item.ObjectItem).Focused);
			else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {
				int index = item.Index;

				if (index == -1 
				    || listView.InvokeSync (l => index >= l.UIAItemsLocationLength))
					return Helper.RectangleToRect (SD.Rectangle.Empty);

				SD.Rectangle itemRec 
					= listView.InvokeSync (c => c.GetItemRect (index));
				SD.Rectangle rectangle 
					= listView.InvokeSync (c => c.Bounds);
				
				itemRec.X += rectangle.X;
				itemRec.Y += rectangle.Y;
				
				itemRec = listView.InvokeSync (c => c.Parent.RectangleToScreen (itemRec));
				
				return Helper.RectangleToRect (itemRec);
			} else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id)
				return Helper.IsListItemOffScreen ((Rect) item.GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id),
				                                   listView, 
				                                   HeaderProvider != null,
				                                   listView.InvokeSync (c => c.UIAHeaderControl),
				                                   ScrollBehaviorObserver);
			else if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)
				return true;

		}
		
		public override int ItemsCount { 
			get { return listView.InvokeSync (c => c.Items.Count); }
		}

		public override int IndexOfObjectItem (object objectItem)
		{
			return listView.InvokeSync (c => c.Items.IndexOf (objectItem as SWF.ListViewItem));
		}
		
		public override void FocusItem (object objectItem)
		{
			listView.InvokeSync (delegate { 
				((SWF.ListViewItem) objectItem).Focused = true; 
			});
		}

		#endregion

		#region ListItem: Selection Methods and Properties
		
		public override int SelectedItemsCount {
			get { return listView.InvokeSync (c => c.SelectedIndices.Count); }
		}
		
		public override bool IsItemSelected (ListItemProvider item)
		{
			return listView.InvokeSync (c => c.SelectedIndices.Contains (item.Index));
		}
		
		public override IRawElementProviderSimple[] GetSelectedItems ()
		{
			if (listView == null)
				return new ListItemProvider [0];
			else {
				ListItemProvider []providers = new ListItemProvider [listView.SelectedItems.Count];

				for (int index = 0; index < listView.SelectedItems.Count; index++)
					providers [index] = GetItemProviderFrom (this, listView.SelectedItems [index], false);
			
			if (listView.InvokeSync (c => c.SelectedIndices.Count == 0))
				return new ListItemProvider [0];
			else {
				return listView.InvokeSync (c => {
					ListItemProvider []providers = new ListItemProvider [c.SelectedItems.Count];
	
					for (int index = 0; index < c.SelectedItems.Count; index++)
						providers [index] = GetItemProviderFrom (this, c.SelectedItems [index], false);
					
					return providers;
				});
			}
		}
		
		public override void SelectItem (ListItemProvider item)
		{
			if (ContainsItem (item) == true)
				listView.InvokeSync (delegate {
					listView.Items [item.Index].Selected = true;
				});
		}

		public override void UnselectItem (ListItemProvider item)
		{
			if (ContainsItem (item) == true)
				listView.InvokeSync (delegate {
					listView.Items [item.Index].Selected = false;
				});
		}
		
		#endregion

		
		public override ToggleState GetItemToggleState (ListItemProvider item)
		{
			if (listView.InvokeSync (c => !c.CheckBoxes)
			    || item.Index == -1)
				return ToggleState.Indeterminate;

			if (ContainsItem (item) == true)
				return listView.InvokeSync (c => c.Items [item.Index].Checked)
					 ? ToggleState.On : ToggleState.Off;
			else
				return ToggleState.Indeterminate;
		}
		
		public override void ToggleItem (ListItemProvider item)
		{
			if (listView.InvokeSync (c => !c.CheckBoxes))
				return;
				
			if (ContainsItem (item) == true)
				listView.InvokeSync (delegate { 
					listView.Items [item.Index].Checked = !listView.Items [item.Index].Checked; 
				});
		}
		
		#endregion

			if (ContainsItem (item) == false)
				return;
			
			listView.InvokeSync(delegate {
				// According to http://msdn.microsoft.com/en-us/library/system.windows.forms.listview.topitem.aspx
				if (listView.View == SWF.View.LargeIcon 
				    || listView.View == SWF.View.SmallIcon
				    || listView.View == SWF.View.Tile)
					return;
				
				listView.TopItem = listView.Items [item.Index];
			});
		}
		
		#endregion

		#region Scroll Methods and Properties
		
		protected override SWF.ScrollBar HorizontalScrollBar { 
			get { return listView.InvokeSync (c => c.UIAHScrollBar); }
		}

		protected override SWF.ScrollBar VerticalScrollBar { 
			get { return listView.InvokeSync (c => c.UIAVScrollBar); }
		}

		#endregion

		public SWF.ListViewGroup GetDefaultGroup ()
		{
			if (listViewNullGroup == null)
				listViewNullGroup = listView.InvokeSync (c => c.UIADefaultListViewGroup);

			return listViewNullGroup;
		}

			// no Groups are added.

			// Using groups
			if (showGroups == true 
			    && listView.InvokeSync (c => c.View != SWF.View.List)
			    && SWF.Application.VisualStylesEnabled == true) {

				SWF.ListViewItem listViewItem = (SWF.ListViewItem) objectItem;

		private void FinalizeProviderFrom (object objectItem)
		{
			// Using groups
			if (showGroups == true 
			    && listView.InvokeSync (c => c.View != SWF.View.List)
			    && SWF.Application.VisualStylesEnabled == true) {

				SWF.ListViewItem listViewItem = (SWF.ListViewItem) objectItem;


		private void UpdateChildrenStructure (bool forceUpdate)
		{
			bool updateView = listView.InvokeSync (c => lastView != c.View);
			
			if (updateView == true || forceUpdate == true) {			
				foreach (ListViewGroupProvider groupProvider in groups.Values) {

				
				ClearItemsList ();
			}
			
			if (listView.InvokeSync (c => c.View == SWF.View.Details)) {
				if (header == null) {
					header = new ListViewHeaderProvider (listView);
					header.Initialize ();

				}
			}
			
			foreach (object objectItem 
			         in listView.InvokeSync (c => c.Items))
				InitializeProviderFrom (objectItem);
		}


			
			UpdateChildrenStructure (false);

			lastView = listView.InvokeSync (c => c.View);
		}

		private void OnUIAShowGroupsChanged (object sender, EventArgs args)
		{
			bool oldValue = showGroups;
			showGroups = listView.InvokeSync (c => c.ShowGroups);
			
			//We will have to regenerate children
			if (listView.InvokeSync (c => c.ShowGroups != oldValue 
			                         && c.View != SWF.View.List)) {
				UpdateChildrenStructure (true);
				if (SWF.Application.VisualStylesEnabled == true)
					SetBehavior (GridPatternIdentifiers.Pattern,


			private Rect HeaderRectangle {
				get {
					return listView.InvokeSync (c => {	
						// Lets Union the Header Bounds			
						SD.Rectangle headerRec = c.UIAGetHeaderBounds (group);
						SD.Rectangle rectangle = c.Bounds;
						
						headerRec.X += rectangle.X;
						headerRec.Y += rectangle.Y;
						
						if (c.FindForm () == c.Parent)
							headerRec = c.TopLevelControl.RectangleToScreen (headerRec);
						else
							headerRec = c.Parent.RectangleToScreen (headerRec);
						
						return Helper.RectangleToRect (headerRec);
					});
				}
			}


			public override void InitializeChildControlStructure ()
			{
				base.InitializeChildControlStructure ();
				
				listView.InvokeSync (delegate {
					//Event used to update columns in ListItem when View.Details
					listView.Columns.UIACollectionChanged += OnUIAColumnsCollectionChanged;
	
					foreach (SWF.ColumnHeader column in listView.Columns) {
						ListViewHeaderItemProvider item 
							= new ListViewHeaderItemProvider (this, column);
						item.Initialize ();
						AddChildProvider (item);
						headerItems [column] = item;
					}
				});
			}

			public override void FinalizeChildControlStructure ()
			{
				base.FinalizeChildControlStructure ();
				
				listView.InvokeSync (delegate {
					//Event used to update columns in ListItem when View.Details
					listView.Columns.UIACollectionChanged -= OnUIAColumnsCollectionChanged;
				});

				foreach (ListViewHeaderItemProvider item in headerItems.Values)
				listView.Columns.UIACollectionChanged -= OnUIAColumnsCollectionChanged;

				foreach (ListViewHeaderItemProvider item in headerItems .Values)
					item.Terminate ();
			}


				else if (propertyId == AutomationElementIdentifiers.IsEnabledProperty.Id)
					return true;
				else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {
					return headerProvider.ListView.InvokeSync (c => {
						int indexOf = c.Columns.IndexOf (columnHeader);
						Rect headerBounds
							= (Rect) headerProvider.GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id);
						if (headerBounds.IsEmpty)
							return headerBounds;
						
						for (int index = 0; index < indexOf; index++)
							headerBounds.X += c.Columns [index].Width;
						
						headerBounds.Width = c.Columns [indexOf].Width;
						
						return headerBounds;
					});					
					for (int index = 0; index < indexOf; index++)
						headerBounds.X += headerProvider.ListView.Columns [index].Width;
					
					headerBounds.Width = headerProvider.ListView.Columns [indexOf].Width;
					
					return headerBounds;
				} else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id) {
					Rect bounds 
						= (Rect) GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id);


			public ListViewListItemEditProvider GetEditProviderAtColumn (int column)
			{
				if (column < 0 
				    || listView.InvokeSync (c => column >= c.Columns.Count))
					return null;

				ListViewListItemEditProvider editProvider = null;
				providers.TryGetValue (listView.InvokeSync (c => c.Columns [column]), 
				                       out editProvider);

				return editProvider;
			}


			protected override object GetProviderPropertyValue (int propertyId)
			{
				if (ListView.InvokeSync (c => c.View == SWF.View.Details)) {
					//According to: http://msdn.microsoft.com/en-us/library/ms742561.aspx
					if (propertyId == AutomationElementIdentifiers.ControlTypeProperty.Id)
						return ControlType.DataItem.Id;

				if (lastView == SWF.View.Details)
					AddEditChildren ();

				if (listView.InvokeSync (c => c.CheckBoxes)) {
					checkboxProvider = new ListViewListItemCheckBoxProvider (this);
					checkboxProvider.Initialize ();
					AddChildProvider (checkboxProvider);


			private void AddEditChildren ()
			{
				foreach (SWF.ColumnHeader column 
				         in listView.InvokeSync (c => c.Columns)) {
					ListViewListItemEditProvider editProvider 
						= new ListViewListItemEditProvider (column, this);
					editProvider.Initialize ();

				if (lastView == SWF.View.Details) {
					providers.Clear ();
					OnNavigationChildrenCleared ();
				} else if (listView.InvokeSync (c => c.View == SWF.View.Details))
					AddEditChildren ();
	
				lastView = listView.InvokeSync (c => c.View);
			}

			private void OnUIAColumnsCollectionChanged (object sender, 
			                                            CollectionChangeEventArgs args)
			{
				if (listView.InvokeSync (c => c.View != SWF.View.Details))
					return;

				SWF.ColumnHeader column = (SWF.ColumnHeader) args.Element;

					IValueProvider valueProvider = (IValueProvider) GetBehavior (ValuePatternIdentifiers.Pattern);
					return valueProvider.Value;
				} else if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)
					return IsFirstColumn || itemProvider.ListView.InvokeSync (c => c.FullRowSelect);
				else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id) {
					if (IsFirstColumn)
						return itemProvider.GetPropertyValue (propertyId);

				else if (propertyId == AutomationElementIdentifiers.LabeledByProperty.Id)
					return null;
				else if (propertyId == AutomationElementIdentifiers.HelpTextProperty.Id) {
					if (itemProvider.ListView.InvokeSync (c => c.Columns.Count == 0 
					                                      || c.Columns [0] == header))
						return string.Empty;
					else
						return itemProvider.ListViewItem.ToolTipText;
				} else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {
					return itemProvider.ListView.InvokeSync (c => {
						int indexOf = c.Columns.IndexOf (header);
						Rect itemBounds
							= (Rect) itemProvider.GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id);
						if (itemBounds.IsEmpty)
							return itemBounds;
	
						for (int index = 0; index < indexOf; index++)
							itemBounds.X += c.Columns [index].Width;
						
						itemBounds.Width = c.Columns [indexOf].Width;
						
						return itemBounds;
					});
					for (int index = 0; index < indexOf; index++)
						itemBounds.X += itemProvider.ListView.Columns [index].Width;
					
					itemBounds.Width = itemProvider.ListView.Columns [indexOf].Width;
					
					return itemBounds;
				} else if (propertyId == AutomationElementIdentifiers.IsOffscreenProperty.Id)
					return Helper.IsListItemOffScreen ((Rect) GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id),
					                                   ItemProvider.ListView, 

Lines 54-60 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/MenuStripProvider.cs (-1 / +1 lines)
54	else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)	54	else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)
55	return Catalog.GetString ("menu bar");	55	return Catalog.GetString ("menu bar");
56	else if (propertyId == AEIds.OrientationProperty.Id) {	56	else if (propertyId == AEIds.OrientationProperty.Id) {
57	switch (menu.Orientation) {	57	switch (menu.InvokeSync (o => menu.Orientation)) {
58	case Orientation.Vertical:	58	case Orientation.Vertical:
59	return OrientationType.Vertical;	59	return OrientationType.Vertical;
60	case Orientation.Horizontal:	60	case Orientation.Horizontal:




		#region Public Methods

		public SWF.MessageBox.MessageBoxForm Form {
			get { return form; }
		}
		
		#endregion

				AddChildProvider (labelProvider);
			}
			if (imageProvider == null
			    && form.InvokeSync (w => w.UIAIconRectangle.Width >= 0)
			    && form.InvokeSync (h => h.UIAIconRectangle.Height >= 0)) {
				
				imageProvider = new MessageBoxImageProvider (this);
				imageProvider.Initialize ();
				AddChildProvider (imageProvider);

				} else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)
					return false;
				else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id)
					return provider.Control.InvokeSync (r => Helper.RectangleToRect (r.TopLevelControl.RectangleToScreen (provider.Form.UIAMessageRectangle)));
				else if (propertyId == AutomationElementIdentifiers.ClickablePointProperty.Id)
					return Helper.GetClickablePoint (this);
				else

				} else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)
					return false;
				else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id)
					return provider.Control.InvokeSync (r => Helper.RectangleToRect (r.TopLevelControl.RectangleToScreen (provider.Form.UIAIconRectangle)));
				else if (propertyId == AutomationElementIdentifiers.ClickablePointProperty.Id)
					return Helper.GetClickablePoint (this);
				else




				throw new ArgumentException ("col");
			}

			SelectionRange range
				= calendar.InvokeSync (c => c.GetDisplayRange (false));
			DateTime date = range.Start.AddDays (
				col + (row * MonthCalendarProvider.DaysInWeek)
			);


#region Selection Helper Methods
		public bool CanSelectMultiple {
			get { return calendar.InvokeSync (c => c.MaxSelectionCount > 1); }
		}

		public int SelectedItemCount {
			get {
				SelectionRange range 
					= calendar.InvokeSync (c => c.SelectionRange);
				return (range.End - range.Start).Days;
			}
		}

		public IRawElementProviderSimple[] GetSelection ()
		{
			SelectionRange range 
				= calendar.InvokeSync (c => c.SelectionRange);
			List<IRawElementProviderSimple> selectedItems
				= new List<IRawElementProviderSimple> ();


				return;
			}

			SelectionRange range 
				= calendar.InvokeSync (c => c.SelectionRange);

			int proposedDays = (range.End - itemProvider.Date).Days;
			if (range.Start > itemProvider.Date) {
				if (proposedDays > calendar.InvokeSync (c => c.MaxSelectionCount)) {
					throw new InvalidOperationException ();
				}



			proposedDays = (itemProvider.Date - range.Start).Days;
			if (range.End < itemProvider.Date) {
				if (proposedDays > calendar.InvokeSync (c => c.MaxSelectionCount)) {
					throw new InvalidOperationException ();
				}

				range.End = itemProvider.Date;
			}

			calendar.InvokeSync (delegate {
				calendar.SelectionRange = range;
			});
		}

		// We can only allow removing from selection on the endpoints.

				throw new InvalidOperationException ();
			}

			SelectionRange range 
				= calendar.InvokeSync (c => c.SelectionRange);
			if (range.Start == range.End) {
				throw new InvalidOperationException ();
			}


		public void SelectItem (MonthCalendarListItemProvider itemProvider)
		{
			calendar.InvokeSync (delegate {
				calendar.SelectionRange
					= new SelectionRange (itemProvider.Date,
					                      itemProvider.Date);
			});
		}

		public bool IsItemSelected (MonthCalendarListItemProvider itemProvider)
		{
			SelectionRange range 
				= calendar.InvokeSync (c => c.SelectionRange);
			return (range.Start <= itemProvider.Date
			        && range.End >= itemProvider.Date);
		}

		private void AddChildren ()
		{
			MonthCalendarListItemProvider item;
			SelectionRange range
				= calendar.InvokeSync (c => c.GetDisplayRange (false));
			for (DateTime d = range.Start;
			     d <= range.End; d = d.AddDays (1)) {
				int days = (d - range.Start).Days;


		private void OnDateChanged (object o, DateRangeEventArgs args)
		{
			SelectionRange range
				= calendar.InvokeSync (c => c.GetDisplayRange (false));
			if (displayRange != null
			    && range.Start == displayRange.Start
			    && range.End == displayRange.End)

			DateTime[] days = new DateTime[days_in_week];

			DateTime sunday = new DateTime (2006, 10, 1);
			DayOfWeek first_day_of_week 
				= calendar.InvokeSync (c => c.GetDayOfWeek (c.FirstDayOfWeek));

			for (int i = 0; i < days.Length; i++) {
				int position = i - (int) first_day_of_week;

Lines 56-62 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/MonthCalendarListItemProvider.cs (-1 / +1 lines)
56	get { return dataGridProvider; }	56	get { return dataGridProvider; }
57	}	57	}
58		58
59	public MonthCalendarProvider MonthCalendarProvider {	59	public MonthCalendarProvider MonthCalendarProvider1 {
60	get { return calendarProvider; }	60	get { return calendarProvider; }
61	}	61	}
62		62

Lines 95-101 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/MonthCalendarProvider.cs (-1 / +1 lines)
95	else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)	95	else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)
96	return Catalog.GetString ("calendar");	96	return Catalog.GetString ("calendar");
97	else if (propertyId == AEIds.NameProperty.Id)	97	else if (propertyId == AEIds.NameProperty.Id)
98	return monthCalendar.SelectionStart.ToShortDateString ();	98	return monthCalendar.InvokeSync (m => m.SelectionStart.ToShortDateString ());
99	return base.GetProviderPropertyValue (propertyId);	99	return base.GetProviderPropertyValue (propertyId);
100	}	100	}
101		101

Lines 38-44 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/PanelProvider.cs (-1 / +1 lines)
38	}	38	}
39		39
40	public override Component Container {	40	public override Component Container {
41	get { return Control.Parent; }	41	get { return Control.InvokeSync (c => c.Parent); }
42	}	42	}
43		43
44	}	44	}

Lines 47-53 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/PropertyGridProvider.cs (-2 / +2 lines)
47	#region SimpleControlProvider: Specializations	47	#region SimpleControlProvider: Specializations
48		48
49	public override Component Container {	49	public override Component Container {
50	get { return Control.Parent; }	50	get { return Control.InvokeSync (c => c.Parent); }
51	}	51	}
52		52
53	#endregion	53	#endregion
Lines 68-74 namespace Mono.UIAutomation.Winforms Link Here
68	#region SimpleControlProvider: Specializations	68	#region SimpleControlProvider: Specializations
69		69
70	public override Component Container {	70	public override Component Container {
71	get { return Control.Parent; }	71	get { return Control.InvokeSync (c => c.Parent); }
72	}	72	}
73		73
74	#endregion	74	#endregion

Lines 50-58 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/PropertyGridTextBoxProvider.cs (-3 / +3 lines)
50	private static TextBoxBase GetPrivateTextBox (PGTextBox pgTextBox)	50	private static TextBoxBase GetPrivateTextBox (PGTextBox pgTextBox)
51	{	51	{
52	// TODO: Replace this with an internal property in SWF	52	// TODO: Replace this with an internal property in SWF
53	return Helper.GetPrivateField<TextBox> (	53	return pgTextBox.InvokeSync (t => Helper.GetPrivateField<TextBox> (typeof (PGTextBox),
54	typeof (PGTextBox), pgTextBox, "textbox"	54	pgTextBox,
55	);	55	"textbox"));
56	}	56	}
57		57
58	#endregion	58	#endregion

Lines 48-54 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/PropertyGridViewProvider.cs (-25 / +30 lines)
48	{	48	{
49	#region Public Properties	49	#region Public Properties
50	public override int SelectedItemsCount {	50	public override int SelectedItemsCount {
51	get { return propertyGrid.SelectedGridItem == null ? 0 : 1; }	51	get {
		52	return propertyGrid.InvokeSync (p => p.SelectedGridItem == null ? 0 : 1);
		53	}
52	}	54	}
53		55
54	public override int ItemsCount {	56	public override int ItemsCount {
Lines 65-73 namespace Mono.UIAutomation.Winforms Link Here
65	: base (propertyGridView)	67	: base (propertyGridView)
66	{	68	{
67	view = propertyGridView;	69	view = propertyGridView;
68	propertyGrid = Helper.GetPrivateField<PropertyGrid> (	70
69	typeof (PropertyGridView), view,	71	propertyGrid = propertyGridView.InvokeSync (c=> Helper.GetPrivateField<PropertyGrid> (
70	"property_grid");	72	typeof (PropertyGridView),
		73	view, "property_grid")
		74	);
71	}	75	}
72		76
73	public override void UnselectItem (ListItemProvider item)	77	public override void UnselectItem (ListItemProvider item)
Lines 81-87 namespace Mono.UIAutomation.Winforms Link Here
81	if (gridItem == null)	85	if (gridItem == null)
82	return;	86	return;
83		87
84	propertyGrid.SelectedGridItem = gridItem;	88	propertyGrid.InvokeSync (delegate {
		89	propertyGrid.SelectedGridItem = gridItem;
		90	});
85	}	91	}
86		92
87	public override void ScrollItemIntoView (ListItemProvider item)	93	public override void ScrollItemIntoView (ListItemProvider item)
Lines 100-106 namespace Mono.UIAutomation.Winforms Link Here
100		106
101	public override bool IsItemSelected (ListItemProvider item)	107	public override bool IsItemSelected (ListItemProvider item)
102	{	108	{
103	return (item.ObjectItem == propertyGrid.SelectedGridItem);	109	return propertyGrid.InvokeSync (p => p.SelectedGridItem == item.ObjectItem);
104	}	110	}
105		111
106	public override int IndexOfObjectItem (object objectItem)	112	public override int IndexOfObjectItem (object objectItem)
Lines 251-259 namespace Mono.UIAutomation.Winforms Link Here
251	private void AddChildren ()	257	private void AddChildren ()
252	{	258	{
253	GridItem root = propertyGrid.RootGridItem;	259	GridItem root = propertyGrid.RootGridItem;
254	if (root == null)
255	return;
256
257	foreach (GridItem cat in root.GridItems) {	260	foreach (GridItem cat in root.GridItems) {
258	if (cat is CategoryGridEntry && cat.GridItems != null && cat.GridItems.Count > 0) {	261	if (cat is CategoryGridEntry && cat.GridItems != null && cat.GridItems.Count > 0) {
259	var catProvider = new PropertyGridCategoryProvider (this, view, (CategoryGridEntry)cat);	262	var catProvider = new PropertyGridCategoryProvider (this, view, (CategoryGridEntry)cat);
Lines 304-325 namespace Mono.UIAutomation.Winforms Link Here
304	{	307	{
305	#region Public Properties	308	#region Public Properties
306	public string Name {	309	public string Name {
307	get { return entry.Label; }	310	get { return view.InvokeSync (v => entry.Label); }
308	}	311	}
309		312
310	public string Value {	313	public string Value {
311	get { return entry.ValueText; }	314	get {
		315	return view.InvokeSync (v => entry.ValueText );
		316	}
312	set {	317	set {
313	string error;	318	view.InvokeSync (delegate {
314	if (!entry.SetValue (value, out error)) {	319	string error;
315	Log.Warn ("PropertyGridListItemProvider: Unable to set value: {0}",	320	if (!entry.SetValue (value, out error)) {
316	error);	321	Log.Warn ("PropertyGridListItemProvider: Unable to set value: {0}",
317	}	322	error);
		323	}
		324	});
318	}	325	}
319	}	326	}
320		327
321	public bool IsReadOnly {	328	public bool IsReadOnly {
322	get { return entry.IsReadOnly && entry.IsEditable; }	329	get { return view.InvokeSync (v => entry.IsReadOnly && entry.IsEditable); }
323	}	330	}
324		331
325	public PropertyGridView PropertyGridView {	332	public PropertyGridView PropertyGridView {
Lines 440-457 namespace Mono.UIAutomation.Winforms Link Here
440	// TODO: Replace this with an internal property	447	// TODO: Replace this with an internal property
441	private int RowHeight {	448	private int RowHeight {
442	get {	449	get {
443	return Helper.GetPrivateField<int> (	450	return view.InvokeSync (
444	typeof (PropertyGridView), view,	451	v => Helper.GetPrivateField<int> (typeof (PropertyGridView), v, "row_height"));
445	"row_height"
446	);
447	}	452	}
448	}	453	}
449		454
450	// TODO: Replace this with an internal property	455	// TODO: Replace this with an internal property
451	private ScrollBar VerticalScrollBar {	456	private ScrollBar VerticalScrollBar {
452	get {	457	get {
453	return Helper.GetPrivateField<ScrollBar> (	458	return view.InvokeSync (
454	typeof (PropertyGridView), view, "vbar"	459	v => Helper.GetPrivateField<ScrollBar> (typeof (PropertyGridView), v, "vbar")
455	);	460	);
456	}	461	}
457	}	462	}
Lines 459-466 namespace Mono.UIAutomation.Winforms Link Here
459	// TODO: Replace this with an internal property	464	// TODO: Replace this with an internal property
460	private int SplitterLocation {	465	private int SplitterLocation {
461	get {	466	get {
462	return Helper.GetPrivateProperty<PropertyGridView, int> (	467	return view.InvokeSync (
463	view, "SplitterLocation"	468	v => Helper.GetPrivateProperty<PropertyGridView, int> (v, "SplitterLocation")
464	);	469	);
465	}	470	}
466	}	471	}




		public bool HasHorizontalScrollbar {
			get {
				return HorizontalScrollBar != null 
					&& HorizontalScrollBar.InvokeSync (c => c.Visible && c.Enabled); 
			}
		}
		
		public bool HasVerticalScrollbar {
			get { 
				return VerticalScrollBar != null 
					&& VerticalScrollBar.InvokeSync (c => c.Visible && c.Enabled); 
			}
		}
	





#region FragmentRootControlProvider Implementation
		public override Component Container {
			get { return Control.InvokeSync (c => c.Parent); }
		}

		public override void InitializeChildControlStructure ()
		{
			base.InitializeChildControlStructure ();

			scrollableControl.InvokeSync (delegate {
				observer = new ScrollBehaviorObserver (
					this, scrollableControl.hscrollbar,
					scrollableControl.vscrollbar);
				observer.ScrollPatternSupportChanged += OnScrollPatternSupportChanged;
				observer.Initialize ();
			});
			UpdateScrollBehavior ();
		}


		{
			// Override Pane's IsKeyboardFocusableProperty
			if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)
				return Control.InvokeSync (c => c.CanFocus && c.CanSelect);

			return base.GetProviderPropertyValue (propertyId);
		}

Lines 76-82 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/SimpleControlProvider.cs (-14 / +18 lines)
76	#region Public Properties	76	#region Public Properties
77		77
78	public virtual Component Container {	78	public virtual Component Container {
79	get { return control != null ? control.Parent : null; }	79	get { return control != null ? control.InvokeSync (c => c.Parent) : null; }
80	}	80	}
81		81
82	public Component Component {	82	public Component Component {
Lines 209-220 namespace Mono.UIAutomation.Winforms Link Here
209	protected virtual System.Drawing.Rectangle ScreenBounds	209	protected virtual System.Drawing.Rectangle ScreenBounds
210	{	210	{
211	get {	211	get {
212	if (Control == null \|\| !Control.Visible)	212	if (Control == null)
213	return System.Drawing.Rectangle.Empty;	213	return System.Drawing.Rectangle.Empty;
		214
		215	return Control.InvokeSync (c => {
		216	if (!c.Visible)
		217	return System.Drawing.Rectangle.Empty;
214		218
215	return Helper.RectToRectangle (	219	return Helper.RectToRectangle (Helper.GetControlScreenBounds (c.Bounds, c));
216	Helper.GetControlScreenBounds (Control.Bounds, Control)	220	});
217	);
218	}	221	}
219	}	222	}
220		223
Lines 281-287 namespace Mono.UIAutomation.Winforms Link Here
281	if (Control == null)	284	if (Control == null)
282	return null;	285	return null;
283	else if (propertyId == AutomationElementIdentifiers.IsEnabledProperty.Id)	286	else if (propertyId == AutomationElementIdentifiers.IsEnabledProperty.Id)
284	return Control.Enabled;	287	return Control.InvokeSync (c => c.Enabled);
285	else if (propertyId == AutomationElementIdentifiers.NameProperty.Id) {	288	else if (propertyId == AutomationElementIdentifiers.NameProperty.Id) {
286	if (!string.IsNullOrEmpty (Control.AccessibleName))	289	if (!string.IsNullOrEmpty (Control.AccessibleName))
287	return Control.AccessibleName;	290	return Control.AccessibleName;
Lines 296-302 namespace Mono.UIAutomation.Winforms Link Here
296	if (controlType == ControlType.Edit.Id \|\| controlType == ControlType.Document.Id)	299	if (controlType == ControlType.Edit.Id \|\| controlType == ControlType.Document.Id)
297	return string.Empty;	300	return string.Empty;
298	else	301	else
299	return Helper.StripAmpersands (Control.Text);	302	return Helper.StripAmpersands (Control.InvokeSync (c => c.Text));
300	} else	303	} else
301	return label.GetPropertyValue (AutomationElementIdentifiers.NameProperty.Id);	304	return label.GetPropertyValue (AutomationElementIdentifiers.NameProperty.Id);
302	} else if (propertyId == AutomationElementIdentifiers.LabeledByProperty.Id) {	305	} else if (propertyId == AutomationElementIdentifiers.LabeledByProperty.Id) {
Lines 326-334 namespace Mono.UIAutomation.Winforms Link Here
326	return closestLabel;	329	return closestLabel;
327		330
328	} else if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)	331	} else if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)
329	return Control.CanFocus && Control.CanSelect;	332	return Control.InvokeSync (c => c.CanFocus && c.CanSelect);
330	else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)	333	else if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)
331	return Control.Focused;	334	return Control.InvokeSync (c => c.Focused);
332	else if (propertyId == AutomationElementIdentifiers.ClickablePointProperty.Id)	335	else if (propertyId == AutomationElementIdentifiers.ClickablePointProperty.Id)
333	return Helper.GetClickablePoint (this);	336	return Helper.GetClickablePoint (this);
334	else if (propertyId == AutomationElementIdentifiers.HelpTextProperty.Id) {	337	else if (propertyId == AutomationElementIdentifiers.HelpTextProperty.Id) {
Lines 337-347 namespace Mono.UIAutomation.Winforms Link Here
337	else	340	else
338	return ToolTip.GetToolTip (Control);	341	return ToolTip.GetToolTip (Control);
339	} else if (propertyId == AutomationElementIdentifiers.AccessKeyProperty.Id) {	342	} else if (propertyId == AutomationElementIdentifiers.AccessKeyProperty.Id) {
340	if (!Control.Text.Contains ("&"))	343	string text = Control.InvokeSync (c => c.Text);
		344	if (!text.Contains ("&"))
341	return null;	345	return null;
342	else {	346	else {
343	int index = Control.Text.LastIndexOf ('&') + 1;	347	int index = text.LastIndexOf ('&') + 1;
344	return "Alt+" + Control.Text.Substring (index, 1);	348	return "Alt+" + text.Substring (index, 1);
345	}	349	}
346	} else	350	} else
347	return null;	351	return null;
Lines 390-399 namespace Mono.UIAutomation.Winforms Link Here
390	public virtual IRawElementProviderSimple HostRawElementProvider {	394	public virtual IRawElementProviderSimple HostRawElementProvider {
391	get {	395	get {
392	// TODO: Address for Components (Strip)	396	// TODO: Address for Components (Strip)
393	if (Control == null \|\| Control.TopLevelControl == null)	397	if (Control == null \|\| Control.InvokeSync (c => c.TopLevelControl == null))
394	return null;	398	return null;
395	else	399	else
396	return AutomationInteropProvider.HostProviderFromHandle (Control.TopLevelControl.Handle);	400	return AutomationInteropProvider.HostProviderFromHandle (Control.InvokeSync (c => c.TopLevelControl.Handle));
397	}	401	}
398	}	402	}
399		403

Lines 95-103 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/SplitContainerProvider.cs (-4 / +7 lines)
95	return ControlType.Pane.Id;	95	return ControlType.Pane.Id;
96	else if (propertyId == AutomationElementIdentifiers.LocalizedControlTypeProperty.Id)	96	else if (propertyId == AutomationElementIdentifiers.LocalizedControlTypeProperty.Id)
97	return Catalog.GetString ("pane");	97	return Catalog.GetString ("pane");
98	else if (propertyId == AutomationElementIdentifiers.OrientationProperty.Id)	98	else if (propertyId == AutomationElementIdentifiers.OrientationProperty.Id) {
99	return ((SplitContainer)Control).Orientation == Orientation.Vertical? OrientationType.Vertical: OrientationType.Horizontal;	99	if (((SplitContainer)Control).InvokeSync (c => c.Orientation) == Orientation.Vertical)
100	else	100	return OrientationType.Vertical;
		101	else
		102	return OrientationType.Horizontal;
		103	} else
101	return base.GetProviderPropertyValue (propertyId);	104	return base.GetProviderPropertyValue (propertyId);
102	}	105	}
103		106
Lines 148-154 namespace Mono.UIAutomation.Winforms Link Here
148	if (propertyId == AutomationElementIdentifiers.ControlTypeProperty.Id)	151	if (propertyId == AutomationElementIdentifiers.ControlTypeProperty.Id)
149	return ControlType.Pane.Id;	152	return ControlType.Pane.Id;
150	else if (propertyId == AutomationElementIdentifiers.LocalizedControlTypeProperty.Id)	153	else if (propertyId == AutomationElementIdentifiers.LocalizedControlTypeProperty.Id)
151	return "pane";	154	return Catalog.GetString ("pane");
152	else if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)	155	else if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)
153	return false;	156	return false;
154	else	157	else




		
		public StatusBarPanelProvider GetPanelProvider (int index)
		{
			return statusBar.InvokeSync (p => {
				StatusBarPanelProvider panel = null;
				
				if (index < 0 || index >= p.Panels.Count)
					return null;
				else if (index >= panels.Count) {
					for (int loop = panels.Count - 1; loop < index; ++loop) {
						panel = new StatusBarPanelProvider (p.Panels [index]);
						panels.Add (panel);
						panel.Initialize ();
					}
				}
				return panels [index];
			});
			
			return panels [index];
		}
		
		public StatusBarPanelProvider RemovePanelAt (int index)




// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
// 
// Copyright (c) 2008,2009 Novell, Inc. (http://www.novell.com) 
// 
// Authors: 
//	Brad Taylor <brad@getcoded.net>

				return ControlType.Tab.Id;
			else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)
				return Catalog.GetString ("tab");
			else if (propertyId == AEIds.OrientationProperty.Id) {
				TabAlignment align = control.InvokeSync (c => c.Alignment);
				return (align == TabAlignment.Top || align == TabAlignment.Bottom)
				       ? Orientation.Horizontal : Orientation.Vertical;
			}

			return base.GetProviderPropertyValue (propertyId);
		}

#endregion

		internal bool HasSelection {
			get { return control.InvokeSync (c => c.SelectedIndex > -1); }
		}

		internal TabPageProvider GetSelectedTab ()
		{
			TabPage page = control.InvokeSync (c => c.SelectedTab);

			if (page == null)
				return null;
			}

			return (TabPageProvider) ProviderFactory.GetProvider (page);
				control.SelectedTab);
		}

		internal void SelectItem (TabPageProvider tabPage)
		{
			control.InvokeSync (delegate {
				control.SelectedTab = (TabPage) tabPage.Control;
			});
		}

		internal bool IsItemSelected (TabPageProvider tabPage)
		{
			return control.InvokeSync (c => c.SelectedTab == (TabPage) tabPage.Control);
		}
		
#region Private Fields




// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
// 
// Copyright (c) 2008,2009 Novell, Inc. (http://www.novell.com) 
// 
// Authors: 
//	Brad Taylor <brad@getcoded.net>

		{
			this.tabPage = control;

			selectionBehavior = new SelectionItemProviderBehavior (this);
			SetBehavior (SelectionItemPatternIdentifiers.Pattern,
				     new SelectionItemProviderBehavior (this));
		}
		
		protected override object GetProviderPropertyValue (int propertyId)

				// want this control's visiblity managed by the
				// TabControl, as tab pages are on-screen even
				// if they report Visible = false.
				return Control.InvokeSync (v => Helper.RectangleToRect (
						v.Parent.RectangleToScreen (tabPage.TabBounds)));
			}

			return base.GetProviderPropertyValue (propertyId);

			// seems to keep a TabPages' children visible even if
			// the TabPage isn't.  This is to model Vista's
			// behavior.
			return Control.InvokeSync (c => c.Visible);
		}

		internal TabControlProvider TabControlProvider {

				return TabControlProvider.IsItemSelected (this);
			}
		}

		public override void SetFocus ()
		{
			//because we want to cause a HasKeyboardFocus property changed event on
			//the tab control, not on the tabpage (as this is how this works on UIA+Vista)
			selectionBehavior.Select ();
		}
		
		private TabPage tabPage;
		private SelectionItemProviderBehavior selectionBehavior;
	}
}




		protected override object GetProviderPropertyValue (int propertyId)
		{
			if (propertyId == AutomationElementIdentifiers.ControlTypeProperty.Id)
				return textboxbase.InvokeSync (c => c.Multiline) ? ControlType.Document.Id : ControlType.Edit.Id;
			else if (propertyId == AutomationElementIdentifiers.LocalizedControlTypeProperty.Id)
				return textboxbase.InvokeSync (c => c.Multiline) ? Catalog.GetString ("document")
				                                     : Catalog.GetString ("edit");
			else 
				return base.GetProviderPropertyValue (propertyId);

		
		internal int MaxLength {
			get {
				return textboxbase.InvokeSync (c => {
					if (textboxbase is TextBox) {
						return ((TextBox) c).MaxLength;
					} else if (textboxbase is RichTextBox) {
						return ((RichTextBox) c).MaxLength;
					} else if (textboxbase is MaskedTextBox) {
						// Length of the mask, removing mask modifiers
						MaskedTextBox mtb = (MaskedTextBox) c;
						if (mtb.MaskedTextProvider != null)
							return mtb.MaskedTextProvider.Length;
						else
							return mtb.Mask.Length;
					}
					return 0;
				});
			}
		}





				// TODO: Refactor this so it isn't so hacky
				MaskedTextBox mtb = textboxbase as MaskedTextBox;
				if (mtb != null && mtb.MaskedTextProvider != null)
					return mtb.InvokeSync (t => t.MaskedTextProvider.ToDisplayString ());
				else
					return textboxbase.InvokeSync (t => textboxbase.Text);
			}
		}
#endregion

		
		private void LineParagraphNormalize (bool is_line)
		{
			if (textboxbase.InvokeSync (t => t.Multiline) == false) {
				start_point = 0;
				end_point = Text.Length;
				return;

Lines 323-328 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/TextRangeProvider.cs (+3 lines)
323	if (length > maxLength && maxLength != -1)	323	if (length > maxLength && maxLength != -1)
324	length = maxLength;	324	length = maxLength;
325		325
		326	if (startPoint + length >= normalizer.Text.Length)
		327	length = normalizer.Text.Length - startPoint;
		328
326	return normalizer.Text.Substring (startPoint, length);	329	return normalizer.Text.Substring (startPoint, length);
327	}	330	}
328		331

Lines 107-127 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/ToolBarProvider.cs (-12 / +16 lines)
107	public ToolBarButtonProvider RemoveButtonAt (int index)	107	public ToolBarButtonProvider RemoveButtonAt (int index)
108	{	108	{
109	ToolBarButtonProvider button = null;	109	ToolBarButtonProvider button = null;
110		110
111	if (index < toolBar.Buttons.Count) {	111	return toolBar.InvokeSync (t => {
112	button = (ToolBarButtonProvider)	112	if (index < t.Buttons.Count) {
113	ProviderFactory.GetProvider (toolBar.Buttons [index]);	113	button = (ToolBarButtonProvider)
114	ProviderFactory.ReleaseProvider (toolBar.Buttons [index]);	114	ProviderFactory.GetProvider (t.Buttons [index]);
115	}	115	ProviderFactory.ReleaseProvider (t.Buttons [index]);
116		116	}
117	return button;	117
		118	return button;
		119	});
118	}	120	}
119		121
120	public void ClearButtonsCollection ()	122	public void ClearButtonsCollection ()
121	{	123	{
122	while (toolBar.Buttons.Count > 0) {	124	toolBar.InvokeSync (delegate {
123	RemoveButtonAt (toolBar.Buttons.Count - 1);	125	while (toolBar.Buttons.Count > 0) {
124	}	126	RemoveButtonAt (toolBar.Buttons.Count - 1);
		127	}
		128	});
125	}	129	}
126		130
127	#endregion	131	#endregion
Lines 134-140 namespace Mono.UIAutomation.Winforms Link Here
134	{	138	{
135	if (e.Action == CollectionChangeAction.Add) {	139	if (e.Action == CollectionChangeAction.Add) {
136	ToolBarButtonProvider button = (ToolBarButtonProvider)	140	ToolBarButtonProvider button = (ToolBarButtonProvider)
137	ProviderFactory.GetProvider (toolBar.Buttons [(int) e.Element]);	141	ProviderFactory.GetProvider (toolBar.InvokeSync (c => c.Buttons [(int) e.Element]));
138	AddChildProvider (button);	142	AddChildProvider (button);
139	} else if (e.Action == CollectionChangeAction.Remove) {	143	} else if (e.Action == CollectionChangeAction.Remove) {
140	ToolBarButtonProvider button = RemoveButtonAt ((int) e.Element);	144	ToolBarButtonProvider button = RemoveButtonAt ((int) e.Element);

Lines 55-65 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/ToolStripButtonProvider.cs (-3 / +11 lines)
55		55
56	protected override object GetProviderPropertyValue (int propertyId)	56	protected override object GetProviderPropertyValue (int propertyId)
57	{	57	{
		58	bool checkOnClick = Owner.InvokeSync (t => button.CheckOnClick);
		59
58	if (propertyId == AEIds.ControlTypeProperty.Id)	60	if (propertyId == AEIds.ControlTypeProperty.Id)
59	return button.CheckOnClick ? ControlType.CheckBox.Id : ControlType.Button.Id;	61	return checkOnClick ? ControlType.CheckBox.Id : ControlType.Button.Id;
60	else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)	62	else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)
61	return button.CheckOnClick ? Catalog.GetString ("checkbox")	63	return checkOnClick ? Catalog.GetString ("checkbox")
62	: Catalog.GetString ("button");	64	: Catalog.GetString ("button");
63	else if (propertyId == AEIds.LabeledByProperty.Id)	65	else if (propertyId == AEIds.LabeledByProperty.Id)
64	return null;	66	return null;
65	else	67	else
Lines 90-95 namespace Mono.UIAutomation.Winforms Link Here
90	#region Private Fields	92	#region Private Fields
91	private ToolStripButton button;	93	private ToolStripButton button;
92	#endregion	94	#endregion
		95
		96	#region Private Properties
		97	private ToolStrip Owner {
		98	get { return ((ToolStripItem) Component).Owner; }
		99	}
		100	#endregion
93	}	101	}
94		102
95	}	103	}

Lines 107-113 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/ToolStripItemProvider.cs (-1 / +4 lines)
107		107
108	public override void SetFocus ()	108	public override void SetFocus ()
109	{	109	{
110	item.Select ();	110	if (item.Owner != null)
		111	item.Owner.InvokeSync (delegate { item.Select (); });
		112	else
		113	item.Select ();
111	}	114	}
112		115
113	}	116	}

Lines 84-94 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/ToolStripLabelProvider.cs (-4 / +9 lines)
84		84
85	protected override object GetProviderPropertyValue (int propertyId)	85	protected override object GetProviderPropertyValue (int propertyId)
86	{	86	{
		87	bool isLink = label.IsLink;
		88
87	if (propertyId == AEIds.ControlTypeProperty.Id)	89	if (propertyId == AEIds.ControlTypeProperty.Id)
88	return label.IsLink ? ControlType.Hyperlink.Id : ControlType.Text.Id;	90	return isLink ? ControlType.Hyperlink.Id : ControlType.Text.Id;
89	else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)	91	else if (propertyId == AEIds.LocalizedControlTypeProperty.Id)
90	return label.IsLink ? Catalog.GetString ("hyperlink")	92	return isLink ? Catalog.GetString ("hyperlink")
91	: Catalog.GetString ("text");	93	: Catalog.GetString ("text");
92	else	94	else
93	return base.GetProviderPropertyValue (propertyId);	95	return base.GetProviderPropertyValue (propertyId);
94	}	96	}
Lines 97-103 namespace Mono.UIAutomation.Winforms Link Here
97		99
98	private void OnIsLinkChanged (object sender, EventArgs args)	100	private void OnIsLinkChanged (object sender, EventArgs args)
99	{	101	{
100	if (label.IsLink) {	102	bool isLink = label.IsLink;
		103
		104	if (isLink) {
101	SetBehavior (InvokePatternIdentifiers.Pattern,	105	SetBehavior (InvokePatternIdentifiers.Pattern,
102	new InvokeProviderBehavior (this));	106	new InvokeProviderBehavior (this));
103	SetEvent (ProviderEventType.TextPatternTextChangedEvent,	107	SetEvent (ProviderEventType.TextPatternTextChangedEvent,
Lines 111-115 namespace Mono.UIAutomation.Winforms Link Here
111	}	115	}
112		116
113	#pragma warning restore 169	117	#pragma warning restore 169
		118
114	}	119	}
115	}	120	}

Lines 60-66 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/ToolStripProvider.cs (-1 / +1 lines)
60	else if (propertyId == AEIds.LabeledByProperty.Id)	60	else if (propertyId == AEIds.LabeledByProperty.Id)
61	return null;	61	return null;
62	else if (propertyId == AEIds.NameProperty.Id)	62	else if (propertyId == AEIds.NameProperty.Id)
63	return Helper.StripAmpersands (strip.Text);	63	return Helper.StripAmpersands (strip.InvokeSync (s => s.Text));
64	else if (propertyId == AEIds.IsContentElementProperty.Id)	64	else if (propertyId == AEIds.IsContentElementProperty.Id)
65	return true;	65	return true;
66	else	66	else

Lines 103-108 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/ToolTipBaseProvider.cs (+7 lines)
103	{	103	{
104	if (AutomationInteropProvider.ClientsAreListening == true) {	104	if (AutomationInteropProvider.ClientsAreListening == true) {
105	message = GetTextFromControl (control);	105	message = GetTextFromControl (control);
		106
		107	// Helper.DelegateQueue.Get ().Enqueue (delegate {
106		108
107	//TODO: We need deeper tests in Vista because MS is generating both events	109	//TODO: We need deeper tests in Vista because MS is generating both events
108	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildAdded,	110	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildAdded,
Lines 113-118 namespace Mono.UIAutomation.Winforms Link Here
113	AutomationInteropProvider.RaiseAutomationEvent (AutomationElementIdentifiers.ToolTipOpenedEvent,	115	AutomationInteropProvider.RaiseAutomationEvent (AutomationElementIdentifiers.ToolTipOpenedEvent,
114	this,	116	this,
115	eventArgs);	117	eventArgs);
		118
		119	// });
116	}	120	}
117	}	121	}
118		122
Lines 120-125 namespace Mono.UIAutomation.Winforms Link Here
120	{	124	{
121	if (AutomationInteropProvider.ClientsAreListening == true) {	125	if (AutomationInteropProvider.ClientsAreListening == true) {
122	message = GetTextFromControl (control);	126	message = GetTextFromControl (control);
		127
		128	// Helper.DelegateQueue.Get ().Enqueue (delegate {
123		129
124	//TODO: We need deeper tests in Vista because MS is generating both events	130	//TODO: We need deeper tests in Vista because MS is generating both events
125	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildRemoved,	131	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildRemoved,
Lines 130-135 namespace Mono.UIAutomation.Winforms Link Here
130	AutomationInteropProvider.RaiseAutomationEvent (AutomationElementIdentifiers.ToolTipClosedEvent,	136	AutomationInteropProvider.RaiseAutomationEvent (AutomationElementIdentifiers.ToolTipClosedEvent,
131	this,	137	this,
132	eventArgs);	138	eventArgs);
		139	// });
133	}	140	}
134	}	141	}
135		142

Lines 84-93 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/TrackBarProvider.cs (-4 / +6 lines)
84	return Catalog.GetString ("slider");	84	return Catalog.GetString ("slider");
85	else if (propertyId == AutomationElementIdentifiers.IsContentElementProperty.Id)	85	else if (propertyId == AutomationElementIdentifiers.IsContentElementProperty.Id)
86	return true;	86	return true;
87	else if (propertyId == AutomationElementIdentifiers.OrientationProperty.Id)	87	else if (propertyId == AutomationElementIdentifiers.OrientationProperty.Id) {
88	return trackBar.Orientation == Orientation.Horizontal	88	if (trackBar.InvokeSync (c => c.Orientation == Orientation.Horizontal))
89	? OrientationType.Horizontal : OrientationType.Vertical;	89	return OrientationType.Horizontal;
90	else	90	else
		91	return OrientationType.Vertical;
		92	} else
91	return base.GetProviderPropertyValue (propertyId);	93	return base.GetProviderPropertyValue (propertyId);
92	}	94	}
93		95

Lines 17-23 Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/TreeViewProvider.cs (-1 / +1 lines)
17	// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION	17	// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
18	// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.	18	// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19	//	19	//
20	// Copyright (c) 2008 Novell, Inc. (http://www.novell.com)	20	// Copyright (c) 2008,2009 Novell, Inc. (http://www.novell.com)
21	//	21	//
22	// Authors:	22	// Authors:
23	// Sandy Armstrong <sanfordarmstrong@gmail.com>	23	// Sandy Armstrong <sanfordarmstrong@gmail.com>

Lines 266-272 namespace MonoTests.Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinformsTests/DataGridProviderTest.cs (-1 / +1 lines)
266	ValuePatternIdentifiers.Pattern.Id) as IValueProvider;	266	ValuePatternIdentifiers.Pattern.Id) as IValueProvider;
267		267
268	Assert.IsNotNull (valueProvider, "Child does not support ValueProvider!");	268	Assert.IsNotNull (valueProvider, "Child does not support ValueProvider!");
269	Assert.IsTrue (valueProvider.IsReadOnly, "Child is not read only.");	269	Assert.IsFalse (valueProvider.IsReadOnly, "Child is read only");
270	}	270	}
271	}	271	}
272		272

Lines 121-126 namespace MonoTests.Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinformsTests/FormProviderTest.cs (+1 lines)
121	}	121	}
122		122
123	[Test]	123	[Test]
		124	[Ignore("Locks")]
124	// FIXME: Add event test	125	// FIXME: Add event test
125	public void IsModalTest ()	126	public void IsModalTest ()
126	{	127	{

Lines 2463-2468 namespace MonoTests.Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinformsTests/ListViewProviderTest.cs (+1 lines)
2463	}	2463	}
2464		2464
2465	[Test]	2465	[Test]
		2466	[Ignore("HeaderItemInvokeProvider does not click when Invoke.Invoke()")]
2466	public void ListViewColumnInvokeTest ()	2467	public void ListViewColumnInvokeTest ()
2467	{	2468	{
2468	var listview = (ListView)GetControlInstance ();	2469	var listview = (ListView)GetControlInstance ();

Return to bug 494034

Lines 71-108 namespace Mono.UIAutomation.Winforms.Behaviors.BaseColorControl Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/BaseColorControl/SmallColorControlInvokeProviderBehavior.cs (-26 / +14 lines)
71		71
72	public virtual void Invoke ()	72	public virtual void Invoke ()
73	{	73	{
74	if (!Provider.Control.Enabled)	74	if (Provider.Control.InvokeSync (e => !e.Enabled))
75	throw new ElementNotEnabledException ();	75	throw new ElementNotEnabledException ();
76		76
77	PerformClick ();	77	Provider.Control.InvokeSync (delegate {
		78	// TODO: Use internal property when backport
		79	// ColorDialog.BaseColorControl.SmallColorControl selected =
		80	// ((ColorDialog.BaseColorControl) baseColorControl).UIASelectedSmallColorControl;
		81	try {
		82	ColorDialog.BaseColorControl.SmallColorControl selected =
		83	Helper.GetPrivateProperty<ColorDialog.BaseColorControl, ColorDialog.BaseColorControl.SmallColorControl>
		84	((ColorDialog.BaseColorControl) baseColorControl, "UIASelectedSmallColorControl");
		85	if (selected != null)
		86	selected.IsSelected = false;
		87	} catch (NotSupportedException) { }
		88	smallColorControl.IsSelected = true;
		89	});
78	}	90	}
79		91
80	#endregion	92	#endregion
81		93
82	#region Private Methods
83
84	private void PerformClick ()
85	{
86	if (Provider.Control.InvokeRequired == true) {
87	Provider.Control.BeginInvoke (new MethodInvoker (PerformClick));
88	return;
89	}
90
91	// TODO: Use internal property when backport
92	// ColorDialog.BaseColorControl.SmallColorControl selected =
93	// ((ColorDialog.BaseColorControl) baseColorControl).UIASelectedSmallColorControl;
94	try {
95	ColorDialog.BaseColorControl.SmallColorControl selected =
96	Helper.GetPrivateProperty<ColorDialog.BaseColorControl, ColorDialog.BaseColorControl.SmallColorControl>
97	((ColorDialog.BaseColorControl) baseColorControl, "UIASelectedSmallColorControl");
98	if (selected != null)
99	selected.IsSelected = false;
100	} catch (NotSupportedException) { }
101	smallColorControl.IsSelected = true;
102	}
103
104	#endregion
105
106	#region Private Field	94	#region Private Field
107		95
108	ColorDialog.BaseColorControl.SmallColorControl smallColorControl;	96	ColorDialog.BaseColorControl.SmallColorControl smallColorControl;

Lines 87-112 namespace Mono.UIAutomation.Winforms.Behaviors.CheckBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/CheckBox/ToggleProviderBehavior.cs (-16 / +12 lines)
87		87
88	public void Toggle ()	88	public void Toggle ()
89	{	89	{
90	if (checkbox.Enabled == false)	90	if (checkbox.InvokeSync (c => !c.Enabled))
91	throw new ElementNotEnabledException ();	91	throw new ElementNotEnabledException ();
92		92
93	switch (checkbox.CheckState) {	93	SWF.CheckState newState = SWF.CheckState.Checked;
		94
		95	switch (checkbox.InvokeSync (c => c.CheckState)) {
94	case SWF.CheckState.Checked:	96	case SWF.CheckState.Checked:
95	PerformToggle (checkbox, SWF.CheckState.Unchecked);	97	newState = SWF.CheckState.Unchecked;
96	break;	98	break;
97	case SWF.CheckState.Unchecked:	99	case SWF.CheckState.Unchecked:
98	if (checkbox.ThreeState)	100	if (checkbox.InvokeSync (c => c.ThreeState))
99	PerformToggle (checkbox, SWF.CheckState.Indeterminate);	101	newState = SWF.CheckState.Indeterminate;
100	else	102	else
101	PerformToggle (checkbox, SWF.CheckState.Checked);	103	newState = SWF.CheckState.Checked;
102	break;	104	break;
103	// Control could still have been set to intermediate	105	// Control could still have been set to intermediate
104	// programatically, regardless of ThreeState value.	106	// programatically, regardless of ThreeState value.
105	case SWF.CheckState.Indeterminate:	107	case SWF.CheckState.Indeterminate:
106	default:	108	default:
107	PerformToggle (checkbox, SWF.CheckState.Checked);	109	newState = SWF.CheckState.Checked;
108	break;	110	break;
109	}	111	}
		112
		113	checkbox.InvokeSync (delegate { PerformToggle (newState); });
110	}	114	}
111		115
112	public ToggleState ToggleState {	116	public ToggleState ToggleState {
Lines 127-140 namespace Mono.UIAutomation.Winforms.Behaviors.CheckBox Link Here
127		131
128	#region Private Methods	132	#region Private Methods
129		133
130	private void PerformToggle (SWF.CheckBox checkbox, SWF.CheckState state)	134	private void PerformToggle (SWF.CheckState state)
131	{	135	{
132	if (checkbox.InvokeRequired == true) {
133	checkbox.BeginInvoke (new PerformToggleDelegate (PerformToggle),
134	new object [] { checkbox, state });
135	return;
136	}
137
138	// NOTE: We can count on presence of InvokeOnClick;	136	// NOTE: We can count on presence of InvokeOnClick;
139	// it is a protected member of CheckBox.	137	// it is a protected member of CheckBox.
140	//	138	//
Lines 151-156 namespace Mono.UIAutomation.Winforms.Behaviors.CheckBox Link Here
151	}	149	}
152	#endregion	150	#endregion
153	}	151	}
154
155	delegate void PerformToggleDelegate (SWF.CheckBox checkbox, SWF.CheckState state);
156	}	152	}

Lines 83-93 namespace Mono.UIAutomation.Winforms.Behaviors.ComboBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ComboBox/ValueProviderBehavior.cs (-20 / +6 lines)
83	#region IValueProvider Interface	83	#region IValueProvider Interface
84		84
85	public bool IsReadOnly {	85	public bool IsReadOnly {
86	get { return Provider.Control.Enabled == false; }	86	get { return Provider.Control.InvokeSync (c => !c.Enabled); }
87	}	87	}
88		88
89	public string Value {	89	public string Value {
90	get { return Provider.Control.Text; }	90	get { return Provider.Control.InvokeSync (c => c.Text); }
91	}	91	}
92		92
93	public void SetValue (string value)	93	public void SetValue (string value)
Lines 95-120 namespace Mono.UIAutomation.Winforms.Behaviors.ComboBox Link Here
95	if (IsReadOnly == true)	95	if (IsReadOnly == true)
96	throw new ElementNotEnabledException ();	96	throw new ElementNotEnabledException ();
97		97
98	PerformSetValue (value);	98	Provider.Control.InvokeSync (delegate {
		99	Provider.Control.Text = value;
		100	});
99	}	101	}
100		102
101	#endregion	103	#endregion
102
103	#region Private Methods
104
105	private void PerformSetValue (string value)
106	{
107	if (Provider.Control.InvokeRequired == true) {
108	Provider.Control.BeginInvoke (new ComboBoxSetValueDelegate (PerformSetValue),
109	new object [] { value } );
110	return;
111	}
112
113	Provider.Control.Text = value;
114	}
115
116	#endregion
117	}	104	}
118		105
119	delegate void ComboBoxSetValueDelegate (string value);
120	}	106	}

Lines 84-94 namespace Mono.UIAutomation.Winforms.Behaviors.DataGrid Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/DataGrid/DataItemEditValueProviderBehavior.cs (-25 / +10 lines)
84	// words an editable style doesn't necessarily mean that you can	84	// words an editable style doesn't necessarily mean that you can
85	// set the value. In Vista Wwhen the cell is not editable and you call	85	// set the value. In Vista Wwhen the cell is not editable and you call
86	// SetValue it will throw an exception so, we are swallowing all the exceptions.	86	// SetValue it will throw an exception so, we are swallowing all the exceptions.
87	PerformSetValue (value);	87
		88	provider.ItemProvider.Control.InvokeSync (delegate {
		89	try {
		90	provider.ItemProvider.SetEditValue (provider, value);
		91	} catch (Exception e) {
		92	// DataSource may throw any exception.
		93	Log.Warn ("{0}: Caught exception:\n{1}", this.GetType (), e);
		94	}
		95	});
88	}	96	}
89		97
90	public bool IsReadOnly {	98	public bool IsReadOnly {
91	get { return provider.Column.ReadOnly; }	99	get { return false; }
92	}	100	}
93		101
94	public string Value {	102	public string Value {
Lines 99-127 namespace Mono.UIAutomation.Winforms.Behaviors.DataGrid Link Here
99		107
100	#region Private Methods	108	#region Private Methods
101		109
102	private void PerformSetValue (string value)
103	{
104	if (IsReadOnly)
105	throw new ElementNotEnabledException ();
106
107	if (provider.ItemProvider.Control.InvokeRequired) {
108	provider.ItemProvider.Control.BeginInvoke (new DataItemSetValueDelegate (PerformSetValue),
109	new object [] { value } );
110	return;
111	}
112
113	try {
114	provider.ItemProvider.SetEditValue (provider, value);
115	} catch (Exception e) {
116	// DataSource may throw any exception.
117	Log.Warn ("{0}: Caught exception:\n{1}", this.GetType (), e);
118	}
119	}
120
121	#endregion
122
123	#region Private Methods
124
125	private DataGridProvider.DataGridDataItemEditProvider provider;	110	private DataGridProvider.DataGridDataItemEditProvider provider;
126		111
127	#endregion	112	#endregion

Lines 76-99 namespace Mono.UIAutomation.Winforms.Behaviors.DataGridView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/DataGridView/DataItemChildInvokeProviderBehavior.cs (-18 / +6 lines)
76	if (provider.Cell.ReadOnly)	76	if (provider.Cell.ReadOnly)
77	throw new ElementNotEnabledException ();	77	throw new ElementNotEnabledException ();
78		78
79	PerformClick ();	79	provider.ItemProvider.DataGridView.InvokeSync (delegate {
80	}	80	SWF.DataGridViewCellEventArgs args
81		81	= new SWF.DataGridViewCellEventArgs (provider.Cell.ColumnIndex,
82	#endregion	82	provider.Cell.RowIndex);
83		83	provider.ItemProvider.DataGridView.InternalOnCellContentClick (args);
84	#region Private Methods	84	});
85
86	private void PerformClick ()
87	{
88	if (provider.ItemProvider.DataGridView.InvokeRequired) {
89	provider.ItemProvider.DataGridView.BeginInvoke (new SWF.MethodInvoker (PerformClick));
90	return;
91	}
92
93	SWF.DataGridViewCellEventArgs args
94	= new SWF.DataGridViewCellEventArgs (provider.Cell.ColumnIndex,
95	provider.Cell.RowIndex);
96	provider.ItemProvider.DataGridView.InternalOnCellContentClick (args);
97	}	85	}
98		86
99	#endregion	87	#endregion

Lines 91-101 namespace Mono.UIAutomation.Winforms.Behaviors.DataGridView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/DataGridView/GridProviderBehavior.cs (-9 / +10 lines)
91	#region IGridProvider implementation	91	#region IGridProvider implementation
92		92
93	public int ColumnCount {	93	public int ColumnCount {
94	get { return gridviewprovider.DataGridView.Columns.Count; }	94	get { return gridviewprovider.DataGridView.InvokeSync (v => v.Columns.Count); }
95	}	95	}
96		96
97	public int RowCount {	97	public int RowCount {
98	get { return gridviewprovider.DataGridView.Rows.Count; }	98	get { return gridviewprovider.DataGridView.InvokeSync (v => v.Rows.Count); }
99	}	99	}
100		100
101	public IRawElementProviderSimple GetItem (int row, int column)	101	public IRawElementProviderSimple GetItem (int row, int column)
Lines 104-116 namespace Mono.UIAutomation.Winforms.Behaviors.DataGridView Link Here
104	if (row < 0 \|\| column < 0 \|\| row >= RowCount \|\| column >= ColumnCount)	104	if (row < 0 \|\| column < 0 \|\| row >= RowCount \|\| column >= ColumnCount)
105	throw new ArgumentOutOfRangeException ();	105	throw new ArgumentOutOfRangeException ();
106		106
107	DataGridViewProvider.DataGridDataItemProvider item	107	return gridviewprovider.DataGridView.InvokeSync (d => {
108	= (DataGridViewProvider.DataGridDataItemProvider) gridviewprovider.GetItemProviderFrom (gridviewprovider,	108	DataGridViewProvider.DataGridDataItemProvider item
109	gridviewprovider.DataGridView.Rows [row],	109	= (DataGridViewProvider.DataGridDataItemProvider) gridviewprovider.GetItemProviderFrom (gridviewprovider,
110	false);	110	d.Rows [row],
111	SWF.DataGridViewColumn viewColumn	111	false);
112	= gridviewprovider.DataGridView.Columns [column];	112	SWF.DataGridViewColumn viewColumn = d.Columns [column];
113	return item.GetChildItem (viewColumn);	113	return item.GetChildItem (viewColumn);
		114	});
114	}	115	}
115		116
116	#endregion	117	#endregion

Lines 69-98 namespace Mono.UIAutomation.Winforms.Behaviors.DateTimePicker Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/DateTimePicker/ButtonInvokeProviderBehavior.cs (-19 / +6 lines)
69	#region IInvokeProvider Members	69	#region IInvokeProvider Members
70	public virtual void Invoke ()	70	public virtual void Invoke ()
71	{	71	{
72	if (!Provider.Control.Enabled)	72	if (Provider.Control.InvokeSync (c => !c.Enabled))
73	throw new ElementNotEnabledException ();	73	throw new ElementNotEnabledException ();
74		74
75	PerformClick ();	75	Provider.Control.InvokeSync (delegate {
76	}	76	((SWF.DateTimePicker) dateTimePicker.Control)
77	#endregion	77	.DropDownButtonClicked ();
78		78	});
79	#region Private Methods
80	private void PerformClick ()
81	{
82	if (Provider.Control.InvokeRequired) {
83	Provider.Control.BeginInvoke (
84	new SWF.MethodInvoker (PerformClick));
85	return;
86	}
87
88	((SWF.DateTimePicker) dateTimePicker.Control)
89	.DropDownButtonClicked ();
90	}	79	}
91	#endregion	80	#endregion
92		81
93	#region Private Fields
94	private DateTimePickerProvider dateTimePicker;	82	private DateTimePickerProvider dateTimePicker;
95	#endregion
96	}	83	}
97		84
98	}	85	}

Lines 108-123 namespace Mono.UIAutomation.Winforms.Behaviors.DateTimePicker Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/DateTimePicker/PartRangeValueProviderBehavior.cs (-25 / +9 lines)
108		108
109	#region IRangeValueProvider Members	109	#region IRangeValueProvider Members
110	public bool IsReadOnly {	110	public bool IsReadOnly {
111	get {	111	get { return dateTimePicker.InvokeSync (b => b.ShowCheckBox && !b.Checked); }
112	return (dateTimePicker.ShowCheckBox
113	&& !dateTimePicker.Checked);
114	}
115	}	112	}
116		113
117	public double Minimum {	114	public double Minimum {
118	get {	115	get {
119	DateTime min = dateTimePicker.MinDate;	116	DateTime min = dateTimePicker.InvokeSync (v => v.MinDate);
120	DateTime cur = dateTimePicker.Value;	117	DateTime cur = dateTimePicker.InvokeSync (v => v.Value);
		118
121	switch (partProvider.PartData.date_time_part) {	119	switch (partProvider.PartData.date_time_part) {
122	case SWF.DateTimePicker.DateTimePart.Seconds:	120	case SWF.DateTimePicker.DateTimePart.Seconds:
123	return IsDateEqual (min, cur) ? min.Second : 0;	121	return IsDateEqual (min, cur) ? min.Second : 0;
Lines 153-160 namespace Mono.UIAutomation.Winforms.Behaviors.DateTimePicker Link Here
153		151
154	public double Maximum {	152	public double Maximum {
155	get {	153	get {
156	DateTime max = dateTimePicker.MaxDate;	154	DateTime max = dateTimePicker.InvokeSync (c => c.MaxDate);
157	DateTime cur = dateTimePicker.Value;	155	DateTime cur = dateTimePicker.InvokeSync (c => c.Value);
158	switch (partProvider.PartData.date_time_part) {	156	switch (partProvider.PartData.date_time_part) {
159	case SWF.DateTimePicker.DateTimePart.Seconds:	157	case SWF.DateTimePicker.DateTimePart.Seconds:
160	return IsDateEqual (max, cur) ? max.Second : 60;	158	return IsDateEqual (max, cur) ? max.Second : 60;
Lines 205-229 namespace Mono.UIAutomation.Winforms.Behaviors.DateTimePicker Link Here
205	if (value < Minimum \|\| value > Maximum)	203	if (value < Minimum \|\| value > Maximum)
206	throw new ArgumentOutOfRangeException ();	204	throw new ArgumentOutOfRangeException ();
207		205
208	PerformSetValue (value);
209	}
210	#endregion
211
212	#region Private Methods
213	private void PerformSetValue (double value)
214	{
215	if (IsReadOnly)	206	if (IsReadOnly)
216	throw new ElementNotEnabledException ();	207	throw new ElementNotEnabledException ();
217		208
218	if (dateTimePicker.InvokeRequired) {	209	dateTimePicker.InvokeSync (delegate {
219	dateTimePicker.BeginInvoke (	210	dateTimePicker.SetPart ((int) value, partProvider.PartData.date_time_part);
220	new DateTimePickerPartSetValueDelegate (PerformSetValue),	211	});
221	new object [] { value }
222	);
223	return;
224	}
225
226	dateTimePicker.SetPart ((int) value, partProvider.PartData.date_time_part);
227	}	212	}
228		213
229	private bool IsDateEqual (DateTime date1, DateTime date2)	214	private bool IsDateEqual (DateTime date1, DateTime date2)
Lines 238-242 namespace Mono.UIAutomation.Winforms.Behaviors.DateTimePicker Link Here
238	#endregion	223	#endregion
239	}	224	}
240		225
241	public delegate void DateTimePickerPartSetValueDelegate (double value);
242	}	226	}

Lines 91-103 namespace Mono.UIAutomation.Winforms.Behaviors.Form Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/Form/TransformProviderBehavior.cs (-20 / +10 lines)
91		91
92	public bool CanMove {	92	public bool CanMove {
93	get {	93	get {
94	return form.WindowState == SWF.FormWindowState.Normal;	94	return form.InvokeSync (f => f.WindowState == SWF.FormWindowState.Normal);
95	}	95	}
96	}	96	}
97		97
98	public bool CanResize {	98	public bool CanResize {
99	get {	99	get {
100	switch (form.FormBorderStyle) {	100	switch (form.InvokeSync (f => f.FormBorderStyle)) {
101	case SWF.FormBorderStyle.Fixed3D:	101	case SWF.FormBorderStyle.Fixed3D:
102	case SWF.FormBorderStyle.FixedDialog:	102	case SWF.FormBorderStyle.FixedDialog:
103	case SWF.FormBorderStyle.FixedSingle:	103	case SWF.FormBorderStyle.FixedSingle:
Lines 119-132 namespace Mono.UIAutomation.Winforms.Behaviors.Form Link Here
119	// exceptions are thrown with bad input	119	// exceptions are thrown with bad input
120	if (!CanMove)	120	if (!CanMove)
121	throw new InvalidOperationException ("CanMove is false");	121	throw new InvalidOperationException ("CanMove is false");
122		122
123	if (form.InvokeRequired == true) {	123	form.InvokeSync (delegate {
124	form.BeginInvoke (new PerformTransformDelegate (Move),	124	form.Location = new Point ((int) x, (int) y);
125	new object [] { x, y});	125	});
126	return;
127	}
128
129	form.Location = new Point ((int) x, (int) y);
130	}	126	}
131		127
132	public void Resize (double width, double height)	128	public void Resize (double width, double height)
Lines 135-148 namespace Mono.UIAutomation.Winforms.Behaviors.Form Link Here
135	// exceptions are thrown with bad input	131	// exceptions are thrown with bad input
136	if (!CanResize)	132	if (!CanResize)
137	throw new InvalidOperationException ("CanResize is false");	133	throw new InvalidOperationException ("CanResize is false");
138		134
139	if (form.InvokeRequired == true) {	135	form.InvokeSync (delegate {
140	form.BeginInvoke (new PerformTransformDelegate (Resize),	136	form.Size = new Size ((int) width, (int) height);
141	new object [] { width, height});	137	});
142	return;
143	}
144
145	form.Size = new Size ((int) width, (int) height);
146	}	138	}
147		139
148	public void Rotate (double degrees)	140	public void Rotate (double degrees)
Lines 159-165 namespace Mono.UIAutomation.Winforms.Behaviors.Form Link Here
159	#endregion	151	#endregion
160		152
161	}	153	}
162
163	delegate void PerformTransformDelegate (double width, double height);
164		154
165	}	155	}

Lines 141-147 namespace Mono.UIAutomation.Winforms.Behaviors.Form Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/Form/WindowProviderBehavior.cs (-32 / +9 lines)
141		141
142	public void SetVisualState (WindowVisualState state)	142	public void SetVisualState (WindowVisualState state)
143	{	143	{
144	SWF.FormWindowState newState = form.WindowState;	144	SWF.FormWindowState newState = form.InvokeSync (f => f.WindowState);
145	switch (state) {	145	switch (state) {
146	case WindowVisualState.Maximized:	146	case WindowVisualState.Maximized:
147	newState = SWF.FormWindowState.Maximized;	147	newState = SWF.FormWindowState.Maximized;
Lines 153-188 namespace Mono.UIAutomation.Winforms.Behaviors.Form Link Here
153	newState = SWF.FormWindowState.Normal;	153	newState = SWF.FormWindowState.Normal;
154	break;	154	break;
155	}	155	}
156	PerformSetVisualState (form, newState);	156
		157	form.InvokeSync (delegate { form.WindowState = newState; });
157	}	158	}
158		159
159	public void Close ()	160	public void Close ()
160	{	161	{
161	form.Close ();	162	form.InvokeSync (delegate { form.Close (); });
162	}	163	}
163		164
164	public bool Minimizable {	165	public bool Minimizable {
165	get {	166	get { return form.InvokeSync (f => f.MinimizeBox); }
166	return form.MinimizeBox;
167	}
168	}	167	}
169		168
170	public bool Maximizable {	169	public bool Maximizable {
171	get {	170	get { return form.InvokeSync (f => f.MaximizeBox); }
172	return form.MaximizeBox;
173	}
174	}	171	}
175		172
176	public bool IsTopmost {	173	public bool IsTopmost {
177	get {	174	get { return form.InvokeSync (f => f.TopMost); }
178	return form.TopMost;
179	}
180	}	175	}
181		176
182	public bool IsModal {	177	public bool IsModal {
183	get {	178	get { return form.InvokeSync (f => f.Modal); }
184	return form.Modal;
185	}
186	}	179	}
187		180
188	public WindowInteractionState InteractionState {	181	public WindowInteractionState InteractionState {
Lines 197-203 namespace Mono.UIAutomation.Winforms.Behaviors.Form Link Here
197		190
198	public WindowVisualState VisualState {	191	public WindowVisualState VisualState {
199	get {	192	get {
200	switch (form.WindowState) {	193	switch (form.InvokeSync (f => f.WindowState)) {
201	case SWF.FormWindowState.Maximized:	194	case SWF.FormWindowState.Maximized:
202	return WindowVisualState.Maximized;	195	return WindowVisualState.Maximized;
203	case SWF.FormWindowState.Minimized:	196	case SWF.FormWindowState.Minimized:
Lines 225-244 namespace Mono.UIAutomation.Winforms.Behaviors.Form Link Here
225		218
226	#endregion	219	#endregion
227		220
228	#region Private Methods
229
230	private void PerformSetVisualState (SWF.Form form, SWF.FormWindowState state)
231	{
232	if (form.InvokeRequired == true) {
233	form.BeginInvoke (new PerformSetVisualStateDelegate (PerformSetVisualState),
234	new object [] { form, state });
235	return;
236	}
237	form.WindowState = state;
238	}
239
240	#endregion
241
242	#region Private Fields	221	#region Private Fields
243		222
244	private bool closing;	223	private bool closing;
Lines 247-252 namespace Mono.UIAutomation.Winforms.Behaviors.Form Link Here
247	#endregion	226	#endregion
248	}	227	}
249		228
250	delegate void PerformSetVisualStateDelegate (SWF.Form form, SWF.FormWindowState state);
251
252	}	229	}

Lines 122-133 namespace Mono.UIAutomation.Winforms.Behaviors.Generic Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/Generic/SelectionItemProviderBehavior.cs (-11 / +7 lines)
122	{	122	{
123	if (IsSelected)	123	if (IsSelected)
124	return;	124	return;
125		125
126	if (itemProvider.ContainerControl.InvokeRequired) {	126	itemProvider.ContainerControl.InvokeSync (delegate {
127	itemProvider.ContainerControl.BeginInvoke (new MethodInvoker (Select));	127	itemProvider.Select ();
128	return;	128	});
129	}
130	itemProvider.Select ();
131	}	129	}
132		130
133	public bool IsSelected {	131	public bool IsSelected {
Lines 165-175 namespace Mono.UIAutomation.Winforms.Behaviors.Generic Link Here
165		163
166	private void PerformUnselect ()	164	private void PerformUnselect ()
167	{	165	{
168	if (itemProvider.ContainerControl.InvokeRequired) {	166	itemProvider.ContainerControl.InvokeSync (delegate {
169	itemProvider.ContainerControl.BeginInvoke (new MethodInvoker (PerformUnselect));	167	itemProvider.Unselect ();
170	return;	168	});
171	}
172	itemProvider.Unselect ();
173	}	169	}
174		170
175	private T itemProvider;	171	private T itemProvider;

Lines 86-124 namespace Mono.UIAutomation.Winforms.Behaviors.LinkLabel Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/LinkLabel/InvokeProviderBehavior.cs (-50 / +43 lines)
86	#region IHypertext Specialization	86	#region IHypertext Specialization
87		87
88	public int NumberOfLinks {	88	public int NumberOfLinks {
89	get { return linkLabel.Links.Count; }	89	get { return linkLabel.InvokeSync (c => c.Links.Count); }
90	}	90	}
91		91
92	public int Start (int index)	92	public int Start (int index)
93	{	93	{
94	if (index >= linkLabel.Links.Count \|\| index < 0)	94	return linkLabel.InvokeSync (c => {
95	return -1;	95	if (index >= c.Links.Count \|\| index < 0)
96	else	96	return -1;
97	return linkLabel.Links [index].Start;	97	else
		98	return c.Links [index].Start;
		99	});
98	}	100	}
99		101
100	public int Length (int index)	102	public int Length (int index)
101	{	103	{
102	if (index >= linkLabel.Links.Count \|\| index < 0)	104	return linkLabel.InvokeSync (c => {
103	return -1;	105	if (index >= c.Links.Count \|\| index < 0)
104	else	106	return -1;
105	return linkLabel.Links [index].Length;	107	else
		108	return c.Links [index].Length;
		109	});
106	}	110	}
107		111
108	public string Uri (int index)	112	public string Uri (int index)
109	{	113	{
110	if (index >= linkLabel.Links.Count \|\| index < 0)	114	return linkLabel.InvokeSync (c => {
111	return null;	115	if (index >= c.Links.Count \|\| index < 0)
112	else	116	return null;
113	return linkLabel.Links [index].LinkData as string;	117	else
		118	return c.Links [index].LinkData as string;
		119	});
114	}	120	}
115		121
116	public bool Enabled (int index)	122	public bool Enabled (int index)
117	{	123	{
118	if (!linkLabel.Enabled \|\| index >= linkLabel.Links.Count \|\| index < 0)	124	return linkLabel.InvokeSync (c => {
119	return false;	125	if (!c.Enabled \|\| index >= c.Links.Count \|\| index < 0)
120	else	126	return false;
121	return linkLabel.Links [index].Enabled;	127	else
		128	return c.Links [index].Enabled;
		129	});
122	}	130	}
123		131
124	public void Invoke (int index)	132	public void Invoke (int index)
Lines 126-166 namespace Mono.UIAutomation.Winforms.Behaviors.LinkLabel Link Here
126	if (!Enabled (index))	134	if (!Enabled (index))
127	throw new ElementNotEnabledException ();	135	throw new ElementNotEnabledException ();
128		136
129	PerformClick (index);	137	linkLabel.InvokeSync (c => {
130	}	138	if (index >= c.Links.Count \|\| index < 0)
131		139	return;
132	#endregion	140
133		141	MethodInfo methodInfo = typeof (SWF.LinkLabel).GetMethod ("OnLinkClicked",
134	#region Private Methods	142	BindingFlags.InvokeMethod
135		143	\| BindingFlags.NonPublic
136	private void PerformClick (int index)	144	\| BindingFlags.Instance);
137	{	145	Action<SWF.LinkLabel, SWF.LinkLabelLinkClickedEventArgs> invokeMethod
138	if (index >= linkLabel.Links.Count \|\| index < 0)	146	= (Action<SWF.LinkLabel, SWF.LinkLabelLinkClickedEventArgs>) Delegate.CreateDelegate
139	return;	147	(typeof (Action<SWF.LinkLabel, SWF.LinkLabelLinkClickedEventArgs>),
140		148	methodInfo);
141	if (linkLabel.InvokeRequired) {	149
142	linkLabel.BeginInvoke (new PerformClickDelegate (PerformClick),	150	SWF.LinkLabelLinkClickedEventArgs args
143	new object [] { index });	151	= new SWF.LinkLabelLinkClickedEventArgs (c.Links [index],
144	return;	152	SWF.MouseButtons.Left);
145	}	153	invokeMethod (c, args);
146		154	});
147	MethodInfo methodInfo = typeof (SWF.LinkLabel).GetMethod ("OnLinkClicked",
148	BindingFlags.InvokeMethod
149	\| BindingFlags.NonPublic
150	\| BindingFlags.Instance);
151	Action<SWF.LinkLabel, SWF.LinkLabelLinkClickedEventArgs> invokeMethod
152	= (Action<SWF.LinkLabel, SWF.LinkLabelLinkClickedEventArgs>) Delegate.CreateDelegate
153	(typeof (Action<SWF.LinkLabel, SWF.LinkLabelLinkClickedEventArgs>),
154	methodInfo);
155
156	SWF.LinkLabelLinkClickedEventArgs args
157	= new SWF.LinkLabelLinkClickedEventArgs (linkLabel.Links [index],
158	SWF.MouseButtons.Left);
159	invokeMethod (linkLabel, args);
160	}	155	}
161		156
162	#endregion	157	#endregion
163	}	158	}
164
165	delegate void PerformClickDelegate (int index);
166	}	159	}

Lines 69-94 namespace Mono.UIAutomation.Winforms.Behaviors.ListItem Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListItem/ScrollItemProviderBehavior.cs (-18 / +4 lines)
69		69
70	public void ScrollIntoView ()	70	public void ScrollIntoView ()
71	{	71	{
72	PerformScrollIntoView (((ListItemProvider) Provider).ListProvider);	72	IListProvider itemProvider = ((ListItemProvider) Provider).ListProvider;
		73	itemProvider.Control.InvokeSync (delegate {
		74	itemProvider.ScrollItemIntoView ((ListItemProvider) Provider);
		75	});
73	}	76	}
74		77
75	#endregion	78	#endregion
76
77	#region Private Methods
78
79	private void PerformScrollIntoView (IListProvider provider)
80	{
81	if (provider.Control.InvokeRequired == true) {
82	provider.Control.BeginInvoke (new ScrollIntoViewDelegate (PerformScrollIntoView),
83	new object [] { provider });
84	return;
85	}
86
87	provider.ScrollItemIntoView ((ListItemProvider) Provider);
88	}
89
90	#endregion
91	}	79	}
92
93	delegate void ScrollIntoViewDelegate (ListProvider provider);
94	}	80	}

Lines 77-102 namespace Mono.UIAutomation.Winforms.Behaviors.ListView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListView/ListItemClipboardProviderBehavior.cs (-17 / +3 lines)
77	position = (int) System.Math.Min (position, text.Length);	77	position = (int) System.Math.Min (position, text.Length);
78		78
79	string newValue = viewItem.Text.Insert (position, SWF.Clipboard.GetText ());	79	string newValue = viewItem.Text.Insert (position, SWF.Clipboard.GetText ());
80	PerformSetValue (newValue);	80	viewItem.ListView.InvokeSync (delegate {
		81	viewItem.Text = newValue;
		82	});
81	}	83	}
82		84
83	#endregion	85	#endregion
84		86
85	#region Private Methods
86
87	private void PerformSetValue (string value)
88	{
89	if (viewItem.ListView.InvokeRequired == true) {
90	viewItem.ListView.BeginInvoke (new ListItemSetValueDelegate (PerformSetValue),
91	new object [] { value } );
92	return;
93	}
94
95	viewItem.Text = value;
96	}
97
98	#endregion
99
100	#region Private Fields	87	#region Private Fields
101		88
102	private SWF.ListViewItem viewItem;	89	private SWF.ListViewItem viewItem;
Lines 104-108 namespace Mono.UIAutomation.Winforms.Behaviors.ListView Link Here
104	#endregion	91	#endregion
105	}	92	}
106		93
107	delegate void ListItemSetValueDelegate (string value);
108	}	94	}

Lines 106-119 namespace Mono.UIAutomation.Winforms.Behaviors.ListView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListView/ListItemEditGridItemProviderBehavior.cs (-2 / +2 lines)
106	public int Row {	106	public int Row {
107	get {	107	get {
108	SWF.ListView listView = editProvider.ItemProvider.ListView;	108	SWF.ListView listView = editProvider.ItemProvider.ListView;
109	return listView.Items.IndexOf (editProvider.ItemProvider.ListViewItem);	109	return listView.InvokeSync (c => c.Items.IndexOf (editProvider.ItemProvider.ListViewItem) );
110	}	110	}
111	}	111	}
112		112
113	public int Column {	113	public int Column {
114	get {	114	get {
115	SWF.ListView listView = editProvider.ItemProvider.ListView;	115	SWF.ListView listView = editProvider.ItemProvider.ListView;
116	return listView.Columns.IndexOf (editProvider.ColumnHeader);	116	return listView.InvokeSync (c => c.Columns.IndexOf (editProvider.ColumnHeader) );
117	}	117	}
118	}	118	}
119		119

Lines 25-31 Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListView/ListItemEmbeddedImageProviderBehavior.cs (-19 / +24 lines)
25		25
26	using System;	26	using System;
27	using System.Windows;	27	using System.Windows;
28	using System.Windows.Forms;	28	using SWF = System.Windows.Forms;
29	using Mono.UIAutomation.Bridge;	29	using Mono.UIAutomation.Bridge;
30	using System.Windows.Automation;	30	using System.Windows.Automation;
31	using Mono.UIAutomation.Winforms;	31	using Mono.UIAutomation.Winforms;
Lines 63-90 namespace Mono.UIAutomation.Winforms.Behaviors.ListView Link Here
63	get {	63	get {
64	ListViewProvider.ListViewListItemProvider itemProvider	64	ListViewProvider.ListViewListItemProvider itemProvider
65	= (ListViewProvider.ListViewListItemProvider) Provider;	65	= (ListViewProvider.ListViewListItemProvider) Provider;
66	ListViewItem item = itemProvider.ObjectItem as ListViewItem;	66	SWF.ListViewItem item = itemProvider.ObjectItem as SWF.ListViewItem;
67	if (item == null \|\| item.ListView == null
68	\|\| (item.ImageIndex == -1 && item.ImageKey == string.Empty))
69	return System.Windows.Rect.Empty;
70
71	ImageList imageList = null;
72	if (item.ListView.View == View.LargeIcon)
73	imageList = item.ListView.LargeImageList;
74	else
75	imageList = item.ListView.SmallImageList;
76		67
77	if (imageList == null)	68	if (item == null \|\| item.ListView == null)
78	return System.Windows.Rect.Empty;	69	return System.Windows.Rect.Empty;
79		70
80	Rect rect = itemProvider.BoundingRectangle;	71	return item.ListView.InvokeSync (c => {
81	rect.Width = imageList.ImageSize.Width;	72	if (item.ImageIndex == -1 && item.ImageKey == string.Empty)
82	rect.Height = imageList.ImageSize.Height;	73	return System.Windows.Rect.Empty;
83
84	if (itemProvider.CheckboxProvider != null)
85	rect.X += itemProvider.CheckboxProvider.BoundingRectangle.Width;
86		74
87	return rect;	75	SWF.ImageList imageList = null;
		76	if (c.View == SWF.View.LargeIcon)
		77	imageList = c.LargeImageList;
		78	else
		79	imageList = c.SmallImageList;
		80
		81	if (imageList == null)
		82	return System.Windows.Rect.Empty;
		83
		84	Rect rect = itemProvider.BoundingRectangle;
		85	rect.Width = imageList.ImageSize.Width;
		86	rect.Height = imageList.ImageSize.Height;
		87
		88	if (itemProvider.CheckboxProvider != null)
		89	rect.X += itemProvider.CheckboxProvider.BoundingRectangle.Width;
		90
		91	return rect;
		92	});
88	}	93	}
89	}	94	}
90		95

Lines 64-166 namespace Mono.UIAutomation.Winforms.Behaviors.MaskedTextBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/MaskedTextBox/InsertDeleteTextProviderBehavior.cs (-81 / +72 lines)
64	// rejected as it contains too many characters.	64	// rejected as it contains too many characters.
65	public void InsertText (string str, ref int position)	65	public void InsertText (string str, ref int position)
66	{	66	{
67	if (maskedTextBox.ReadOnly)	67	if (maskedTextBox.InvokeSync (m => m.ReadOnly))
68	throw new ElementNotEnabledException ();	68	throw new ElementNotEnabledException ();
69		69
70	if (Provider.Control.InvokeRequired) {	70	int newPosition = position;
71	object[] args = new object[] { str, position };	71
72	Provider.Control.BeginInvoke (new InsertTextDelegate (InsertText), args);	72	maskedTextBox.InvokeSync (delegate {
73	position = (int) args[1];	73
74	return;	74	System.ComponentModel.MaskedTextProvider prov
75	}	75	= maskedTextBox.MaskedTextProvider;
76		76
77	System.ComponentModel.MaskedTextProvider prov	77	string text = prov.ToDisplayString ();
78	= maskedTextBox.MaskedTextProvider;	78
79		79	int offset = newPosition;
80	string text = prov.ToDisplayString ();	80	for (int i = 0; i < str.Length; i++) {
81		81	int localOffset = offset;
82	int offset = position;	82
83	for (int i = 0; i < str.Length; i++) {	83	// skip over an unavailable slot if we see one
84	int localOffset = offset;	84	bool reachedBounds = false;
85		85	while (!prov.IsEditPosition (i + localOffset)) {
86	// skip over an unavailable slot if we see one	86	localOffset++;
87	bool reachedBounds = false;	87	if (i + localOffset >= prov.Length) {
88	while (!prov.IsEditPosition (i + localOffset)) {	88	reachedBounds = true;
89	localOffset++;	89	break;
90	if (i + localOffset >= prov.Length) {	90	}
91	reachedBounds = true;	91	}
		92
		93	if (reachedBounds)
92	break;	94	break;
		95
		96	// There is already a character here, so while
		97	// the GUI will actually move this character
		98	// over, we cannot as there are _many, many_
		99	// edge cases that we cannot handle.
		100	// Instead, we skip over the character.
		101	if (!prov.IsAvailablePosition (i + localOffset)) {
		102	// Make sure offset is correct for the
		103	// next iteration
		104	offset = localOffset;
		105	continue;
93	}	106	}
94	}	107
95		108	// The correct value of position is equal to
96	if (reachedBounds)	109	// the localOffset of the first character.
97	break;	110	//
98		111	// This check needs to be done after
99	// There is already a character here, so while	112	// IsAvailablePosition in case we are trying to
100	// the GUI will actually move this character	113	// insert into a place that already has a
101	// over, we cannot as there are _many, many_	114	// character.
102	// edge cases that we cannot handle.	115	if (offset != localOffset && i == 0)
103	// Instead, we skip over the character.	116	newPosition = localOffset;
104	if (!prov.IsAvailablePosition (i + localOffset)) {	117
105	// Make sure offset is correct for the
106	// next iteration
107	offset = localOffset;	118	offset = localOffset;
108	continue;	119
		120	text = text.Substring (0, i + offset)
		121	+ str[i] + text.Substring (i + offset + 1);
109	}	122	}
110		123
111	// The correct value of position is equal to	124	maskedTextBox.Text = text;
112	// the localOffset of the first character.	125	});
113	//	126
114	// This check needs to be done after	127	position = newPosition;
115	// IsAvailablePosition in case we are trying to
116	// insert into a place that already has a
117	// character.
118	if (offset != localOffset && i == 0)
119	position = localOffset;
120
121	offset = localOffset;
122
123	text = text.Substring (0, i + offset)
124	+ str[i] + text.Substring (i + offset + 1);
125	}
126
127	maskedTextBox.Text = text;
128	}	128	}
129		129
130	public void DeleteText (int start, int end)	130	public void DeleteText (int start, int end)
131	{	131	{
132	if (maskedTextBox.ReadOnly)	132	if (maskedTextBox.InvokeSync (m => m.ReadOnly))
133	throw new ElementNotEnabledException ();	133	throw new ElementNotEnabledException ();
134		134
135	if (Provider.Control.InvokeRequired) {	135	maskedTextBox.InvokeSync (delegate {
136	Provider.Control.BeginInvoke (new DeleteTextDelegate (DeleteText),	136	// MaskedTextProvider.RemoveAt does not work for this.
137	new object [] {start, end});	137	System.ComponentModel.MaskedTextProvider prov
138	return;	138	= maskedTextBox.MaskedTextProvider;
139	}	139
140		140	string text = prov.ToDisplayString ();
141	// MaskedTextProvider.RemoveAt does not work for this.	141	for (int i = start; i < end; i++) {
142	System.ComponentModel.MaskedTextProvider prov	142	if (!prov.IsEditPosition (i)
143	= maskedTextBox.MaskedTextProvider;	143	\|\| prov.IsAvailablePosition (i))
144		144	continue;
145	string text = prov.ToDisplayString ();	145
146	for (int i = start; i < end; i++) {	146	text = text.Substring (0, i) + prov.PromptChar
147	if (!prov.IsEditPosition (i)	147	+ text.Substring (i + 1);
148	\|\| prov.IsAvailablePosition (i))	148	}
149	continue;
150
151	text = text.Substring (0, i) + prov.PromptChar
152	+ text.Substring (i + 1);
153	}
154		149
155	maskedTextBox.Text = text;	150	maskedTextBox.Text = text;
		151	});
156	}	152	}
157	#endregion	153	#endregion
158		154
159	#region Private Delegates
160	private delegate void InsertTextDelegate (string str, ref int position);
161	private delegate void DeleteTextDelegate (int start, int end);
162	#endregion
163
164	#region Private Fields	155	#region Private Fields
165	private SWF.MaskedTextBox maskedTextBox;	156	private SWF.MaskedTextBox maskedTextBox;
166	#endregion	157	#endregion

Lines 65-92 namespace Mono.UIAutomation.Winforms.Behaviors.NumericUpDown Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/NumericUpDown/EditableRangeProviderBehavior.cs (-21 / +14 lines)
65	#region IEditableRange Members	65	#region IEditableRange Members
66	public void BeginEdit (string text)	66	public void BeginEdit (string text)
67	{	67	{
68	if (numericUpDown.ReadOnly)	68	if (numericUpDown.InvokeSync (n => numericUpDown.ReadOnly))
69	throw new ElementNotEnabledException ();	69	throw new ElementNotEnabledException ();
70	if (numericUpDown.InvokeRequired == true) {	70
71	numericUpDown.BeginInvoke (new NumericUpDownBeginEditDelegate (BeginEdit),	71	numericUpDown.InvokeSync (delegate {
72	new object [] { text });	72	numericUpDown.txtView.Text = text;
73	return;	73	});
74	}
75	numericUpDown.txtView.Text = text;
76	}	74	}
77		75
78	public void CommitEdit ()	76	public void CommitEdit ()
79	{	77	{
80	if (numericUpDown.InvokeRequired) {	78	numericUpDown.InvokeSync (delegate {
81	numericUpDown.BeginInvoke (new NumericUpDownCommitEditDelegate (CommitEdit));	79	decimal value = decimal.Parse (numericUpDown.Text);
82	return;	80	if (value < numericUpDown.Minimum)
83	}	81	value = numericUpDown.Minimum;
84	decimal value = decimal.Parse (numericUpDown.Text);	82	if (value > numericUpDown.Maximum)
85	if (value < numericUpDown.Minimum)	83	value = numericUpDown.Maximum;
86	value = numericUpDown.Minimum;	84	numericUpDown.Value = value;
87	if (value > numericUpDown.Maximum)	85	});
88	value = numericUpDown.Maximum;
89	numericUpDown.Value = value;
90	}	86	}
91	#endregion	87	#endregion
92		88
Lines 95-102 namespace Mono.UIAutomation.Winforms.Behaviors.NumericUpDown Link Here
95	private SWF.NumericUpDown numericUpDown;	91	private SWF.NumericUpDown numericUpDown;
96		92
97	#endregion	93	#endregion
98	}	94	}
99
100	delegate void NumericUpDownBeginEditDelegate (string value);
101	delegate void NumericUpDownCommitEditDelegate ();
102	}	95	}

Lines 63-83 namespace Mono.UIAutomation.Winforms.Behaviors.PictureBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/PictureBox/EmbeddedImageProviderBehavior.cs (-14 / +19 lines)
63	#region IEmbeddedImageProvider Interface	63	#region IEmbeddedImageProvider Interface
64	public Rect Bounds {	64	public Rect Bounds {
65	get {	65	get {
66	if (control.Image == null)	66	return control.InvokeSync (c => {
67	return Rect.Empty;	67	if (c.Image == null)
68	GraphicsUnit unit = GraphicsUnit.Pixel;	68	return Rect.Empty;
69	RectangleF rectF = control.Image.GetBounds (ref unit);
70	if (unit != GraphicsUnit.Pixel)
71	return Rect.Empty;
72		69
73	System.Windows.Rect ret	70	GraphicsUnit unit = GraphicsUnit.Pixel;
74	= (System.Windows.Rect) Provider.GetPropertyValue (	71	RectangleF rectF = c.Image.GetBounds (ref unit);
75	AutomationElementIdentifiers.BoundingRectangleProperty.Id);	72
76	ret.X += rectF.X;	73	if (unit != GraphicsUnit.Pixel)
77	ret.Y += rectF.Y;	74	return Rect.Empty;
78	ret.Width = rectF.Width;	75
79	ret.Height = rectF.Height;	76	System.Windows.Rect ret
80	return ret;	77	= (System.Windows.Rect) Provider.GetPropertyValue (
		78	AutomationElementIdentifiers.BoundingRectangleProperty.Id);
		79	ret.X += rectF.X;
		80	ret.Y += rectF.Y;
		81	ret.Width = rectF.Width;
		82	ret.Height = rectF.Height;
		83	return ret;
		84	}
		85	);
81	}	86	}
82	}	87	}
83		88

Lines 120-126 namespace Mono.UIAutomation.Winforms.Behaviors.RadioButton Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/RadioButton/SelectionItemProviderBehavior.cs (-17 / +3 lines)
120		120
121	public void Select ()	121	public void Select ()
122	{	122	{
123	PerformSelectDelegate (radioButton);	123	radioButton.InvokeSync (delegate {
		124	radioButton.Checked = true;
		125	});
124	}	126	}
125		127
126	public IRawElementProviderSimple SelectionContainer {	128	public IRawElementProviderSimple SelectionContainer {
Lines 134-154 namespace Mono.UIAutomation.Winforms.Behaviors.RadioButton Link Here
134	}	136	}
135		137
136	#endregion	138	#endregion
137
138	#region Private Methods
139
140	private void PerformSelectDelegate (SWF.RadioButton radioButton)
141	{
142	if (radioButton.InvokeRequired == true) {
143	radioButton.BeginInvoke (new PerformSelectDelegate (PerformSelectDelegate),
144	new object [] { radioButton });
145	return;
146	}
147	radioButton.Checked = true;
148	}
149
150	#endregion
151	}	139	}
152
153	delegate void PerformSelectDelegate (SWF.RadioButton radioButton);
154	}	140	}

Lines 76-95 namespace Mono.UIAutomation.Winforms.Behaviors.SplitContainer Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/SplitContainer/DockProviderBehavior.cs (-10 / +4 lines)
76	#region IDockProvider Members	76	#region IDockProvider Members
77		77
78	public DockPosition DockPosition {	78	public DockPosition DockPosition {
79	get { return Helper.GetDockPosition (splitContainer.Dock); }	79	get { return splitContainer.InvokeSync (s => Helper.GetDockPosition (s.Dock)); }
80	}	80	}
81		81
82	public void SetDockPosition (DockPosition dockPosition)	82	public void SetDockPosition (DockPosition dockPosition)
83	{	83	{
84	//throw new InvalidOperationException ();	84	//throw new InvalidOperationException ();
85		85
86	if (splitContainer.InvokeRequired == true) {	86	splitContainer.InvokeSync (delegate {
87	splitContainer.BeginInvoke (new PerformSetDockPositionDelegate (SetDockPosition),	87	splitContainer.Dock = Helper.GetDockStyle (dockPosition);
88	new object [] { dockPosition });	88	});
89	return;
90	}
91
92	splitContainer.Dock = Helper.GetDockStyle (dockPosition);
93	}	89	}
94		90
95	#endregion	91	#endregion
Lines 100-105 namespace Mono.UIAutomation.Winforms.Behaviors.SplitContainer Link Here
100		96
101	#endregion	97	#endregion
102	}	98	}
103
104	delegate void PerformSetDockPositionDelegate (DockPosition dockPosition);
105	}	99	}

Lines 98-113 namespace Mono.UIAutomation.Winforms.Behaviors.Splitter Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/Splitter/TransformProviderBehavior.cs (-10 / +6 lines)
98		98
99	public void Move (double x, double y)	99	public void Move (double x, double y)
100	{	100	{
101	if (splitter.InvokeRequired == true) {	101	splitter.InvokeSync (delegate {
102	splitter.BeginInvoke (new PerformMoveDelegate (Move),	102	if (splitter.Dock == SWF.DockStyle.Left \|\| splitter.Dock == SWF.DockStyle.Right)
103	new object [] { x, y });	103	splitter.SplitPosition = (int) x;
104	return;	104	else
105	}	105	splitter.SplitPosition = (int) y;
106		106	});
107	if (splitter.Dock == SWF.DockStyle.Left \|\| splitter.Dock == SWF.DockStyle.Right)
108	splitter.SplitPosition = (int) x;
109	else
110	splitter.SplitPosition = (int) y;
111	}	107	}
112		108
113	public void Resize (double width, double height)	109	public void Resize (double width, double height)

Lines 62-97 namespace Mono.UIAutomation.Winforms.Behaviors.TextBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/TextBox/ClipboardProviderBehavior.cs (-27 / +34 lines)
62		62
63	public void Copy (int start, int end)	63	public void Copy (int start, int end)
64	{	64	{
65	string text = Text;	65	TextBoxBase.InvokeSync (delegate {
66	start = (int) System.Math.Max (start, 0);	66	string text = Text;
67	end = (int) System.Math.Min (end, text.Length);	67	start = (int) System.Math.Max (start, 0);
68	SWF.Clipboard.SetText (text.Substring (start, end - start));	68	end = (int) System.Math.Min (end, text.Length);
		69	SWF.Clipboard.SetText (text.Substring (start, end - start));
		70	});
69	}	71	}
70		72
71	public void Paste (int position)	73	public void Paste (int position)
72	{	74	{
73	string text = Text;	75	TextBoxBase.InvokeSync (delegate {
74	position = (int) System.Math.Max (position, 0);	76	string text = Text;
75	position = (int) System.Math.Min (position, text.Length);	77	position = (int) System.Math.Max (position, 0);
		78	position = (int) System.Math.Min (position, text.Length);
76		79
77	// If you were to paste using the GUI, it would only	80	// If you were to paste using the GUI, it would only
78	// paste enough until the control was full, so emulate	81	// paste enough until the control was full, so emulate
79	// that behavior.	82	// that behavior.
80	int maxLength = 0;	83	int maxLength = 0;
81	if (Provider is TextBoxProvider)	84	if (Provider is TextBoxProvider)
82	maxLength = ((TextBoxProvider) Provider).MaxLength;	85	maxLength = ((TextBoxProvider) Provider).MaxLength;
83		86
84	string clipboardText = SWF.Clipboard.GetText ();	87	string clipboardText = SWF.Clipboard.GetText ();
85	if (maxLength > 0 && clipboardText.Length > (maxLength - position))	88	if (maxLength > 0 && clipboardText.Length > (maxLength - position))
86	clipboardText = clipboardText.Substring (0, maxLength - position);	89	clipboardText = clipboardText.Substring (0, maxLength - position);
87		90
88	IInsertDeleteTextProvider insertDeleteProv	91	IInsertDeleteTextProvider insertDeleteProv
89	= Provider.GetPatternProvider (InsertDeleteTextPatternIdentifiers.Pattern.Id)	92	= Provider.GetPatternProvider (InsertDeleteTextPatternIdentifiers.Pattern.Id)
90	as IInsertDeleteTextProvider;	93	as IInsertDeleteTextProvider;
91	if (insertDeleteProv != null)	94	if (insertDeleteProv != null)
92	insertDeleteProv.InsertText (clipboardText, ref position);	95	insertDeleteProv.InsertText (clipboardText, ref position);
93	else	96	else
94	TextBoxBase.Text = text.Insert (position, clipboardText);	97	TextBoxBase.Text = text.Insert (position, clipboardText);
		98	});
95	}	99	}
96		100
97	#endregion	101	#endregion
Lines 101-107 namespace Mono.UIAutomation.Winforms.Behaviors.TextBox Link Here
101	if (Provider.Control is SWF.TextBoxBase)	105	if (Provider.Control is SWF.TextBoxBase)
102	return (SWF.TextBoxBase)Provider.Control;	106	return (SWF.TextBoxBase)Provider.Control;
103	else if (Provider.Control is SWF.UpDownBase)	107	else if (Provider.Control is SWF.UpDownBase)
104	return ((SWF.UpDownBase)Provider.Control).txtView;	108	return ((SWF.UpDownBase)Provider.Control).InvokeSync (c => c.txtView);
105	else	109	else
106	throw new Exception ("TextBoxBase: Unknown type: " + Provider.Control);	110	throw new Exception ("TextBoxBase: Unknown type: " + Provider.Control);
107	}	111	}
Lines 110-120 namespace Mono.UIAutomation.Winforms.Behaviors.TextBox Link Here
110	private string Text {	114	private string Text {
111	get {	115	get {
112	if (TextBoxBase is SWF.MaskedTextBox)	116	if (TextBoxBase is SWF.MaskedTextBox)
113	return ((SWF.MaskedTextBox) TextBoxBase).MaskedTextProvider.ToDisplayString ();	117	return ((SWF.MaskedTextBox) TextBoxBase).InvokeSync (c => c.MaskedTextProvider.ToDisplayString ());
114	else	118	else
115	return TextBoxBase.Text;	119	return TextBoxBase.InvokeSync (c => c.Text);
		120	}
		121	set {
		122	SWF.TextBoxBase textBoxBase = TextBoxBase;
		123	textBoxBase.InvokeSync (delegate { textBoxBase.Text = value; });
116	}	124	}
117	set { TextBoxBase.Text = value; }
118	}	125	}
119		126
120	}	127	}

Lines 83-101 namespace Mono.UIAutomation.Winforms.Behaviors.TextBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/TextBox/ValueProviderBehavior.cs (-28 / +18 lines)
83	#region IValueProvider: Specialization	83	#region IValueProvider: Specialization
84		84
85	public bool IsReadOnly {	85	public bool IsReadOnly {
86	get { return ((SWF.TextBoxBase) Provider.Control).ReadOnly \|\| !Provider.Control.Enabled; }	86	get {
		87	return ((SWF.TextBoxBase) Provider.Control).InvokeSync (c => c.ReadOnly
		88	\|\| !c.Enabled);
		89	}
87	}	90	}
88		91
89	public string Value {	92	public string Value {
90	get {	93	get {
91	if (Provider.Control is SWF.MaskedTextBox) {	94	if (Provider.Control is SWF.MaskedTextBox) {
92	System.ComponentModel.MaskedTextProvider mtp	95	System.ComponentModel.MaskedTextProvider mtp
93	= ((SWF.MaskedTextBox) Provider.Control).MaskedTextProvider;	96	= ((SWF.MaskedTextBox) Provider.Control).InvokeSync (c => c.MaskedTextProvider);
94	if (mtp != null)	97	if (mtp != null) {
95	return mtp.ToDisplayString ();	98	return mtp.ToDisplayString ();
		99	}
96	}	100	}
97		101
98	return Provider.Control.Text;	102	return Provider.Control.InvokeSync (c => c.Text);
99	}	103	}
100	}	104	}
101		105
Lines 104-134 namespace Mono.UIAutomation.Winforms.Behaviors.TextBox Link Here
104	if (IsReadOnly)	108	if (IsReadOnly)
105	throw new ElementNotEnabledException ();	109	throw new ElementNotEnabledException ();
106		110
107	PerformSetValue (value);	111	Provider.Control.InvokeSync (delegate {
108	}	112	int maxLength = ((TextBoxProvider) Provider).MaxLength;
109		113	if (maxLength > 0
110	#endregion	114	&& value.Length > maxLength) {
111		115	value = value.Substring (0, maxLength);
112	#region Private Members	116	}
113		117
114	private void PerformSetValue (string value)	118	Provider.Control.Text = value;
115	{	119	}
116	if (Provider.Control.InvokeRequired) {	120	);
117	Provider.Control.BeginInvoke (new SetValueDelegate (PerformSetValue),
118	new object [] {value});
119	return;
120	}
121
122	int maxLength = ((TextBoxProvider) Provider).MaxLength;
123	if (maxLength > 0
124	&& value.Length > maxLength) {
125	value = value.Substring (0, maxLength);
126	}
127
128	Provider.Control.Text = value;
129	}	121	}
130
131	private delegate void SetValueDelegate (string val);
132		122
133	#endregion	123	#endregion
134	}	124	}

Lines 77-91 namespace Mono.UIAutomation.Winforms.Behaviors.ToolBar Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ToolBar/ToolBarButtonExpandCollapseProviderBehavior.cs (-14 / +11 lines)
77		77
78	#region IExpandCollapseProvider Members	78	#region IExpandCollapseProvider Members
79		79
80	public ExpandCollapseState ExpandCollapseState	80	public ExpandCollapseState ExpandCollapseState {
81	{
82	get {	81	get {
83	SWF.Menu menu = toolBarButton.DropDownMenu;	82	SWF.Menu menu = toolBarButton.DropDownMenu;
84	if (menu == null)	83	if (menu == null)
85	return ExpandCollapseState.Collapsed;	84	return ExpandCollapseState.Collapsed;
86		85
87	return toolBarButton.Pushed ? ExpandCollapseState.Expanded	86	return toolBar.InvokeSync (t => toolBarButton.Pushed ? ExpandCollapseState.Expanded
88	: ExpandCollapseState.Collapsed;	87	: ExpandCollapseState.Collapsed
		88	);
89	}	89	}
90	}	90	}
91		91
Lines 111-126 namespace Mono.UIAutomation.Winforms.Behaviors.ToolBar Link Here
111		111
112	private void PerformExpandCollapse ()	112	private void PerformExpandCollapse ()
113	{	113	{
114	if (toolBar.InvokeRequired == true) {	114	toolBar.InvokeSync (delegate {
115	toolBar.BeginInvoke (new SWF.MethodInvoker (PerformExpandCollapse));	115	SWF.ContextMenu menu = toolBarButton.DropDownMenu as SWF.ContextMenu;
116	return;	116	if (menu == null)
117	}	117	return;
118		118	menu.Show (toolBar,
119	SWF.ContextMenu menu = toolBarButton.DropDownMenu as SWF.ContextMenu;	119	new Point (toolBarButton.Rectangle.X, toolBar.Height));
120	if (menu == null)	120	});
121	return;
122	menu.Show (toolBar,
123	new Point (toolBarButton.Rectangle.X, toolBar.Height));
124	}	121	}
125		122
126	#endregion	123	#endregion

Lines 79-85 namespace Mono.UIAutomation.Winforms.Behaviors.ToolBar Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ToolBar/ToolBarButtonToggleProviderBehavior.cs (-16 / +4 lines)
79	public ToggleState ToggleState	79	public ToggleState ToggleState
80	{	80	{
81	get {	81	get {
82	if (toolBarButton.Pushed)	82	if (toolBar.InvokeSync (t => toolBarButton.Pushed))
83	return ToggleState.On;	83	return ToggleState.On;
84	else	84	else
85	return ToggleState.Off;	85	return ToggleState.Off;
Lines 91-111 namespace Mono.UIAutomation.Winforms.Behaviors.ToolBar Link Here
91	if (!toolBarButton.Enabled)	91	if (!toolBarButton.Enabled)
92	throw new ElementNotEnabledException ();	92	throw new ElementNotEnabledException ();
93		93
94	PerformToggle ();	94	toolBar.InvokeSync (delegate {
95	}	95	toolBar.UIAPerformClick (toolBarButton);
96		96	});
97	#endregion
98
99	#region Private Methods
100
101	private void PerformToggle ()
102	{
103	if (toolBar.InvokeRequired == true) {
104	toolBar.BeginInvoke (new SWF.MethodInvoker (PerformToggle));
105	return;
106	}
107
108	toolBar.UIAPerformClick (toolBarButton);
109	}	97	}
110		98
111	#endregion	99	#endregion

Lines 71-87 namespace Mono.UIAutomation.Winforms.Behaviors.ToolStripButton Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ToolStripButton/InvokeProviderBehavior.cs (-11 / +4 lines)
71	if (button.Enabled == false)	71	if (button.Enabled == false)
72	throw new ElementNotEnabledException ();	72	throw new ElementNotEnabledException ();
73		73
74	PerformClick ();	74	SWF.ToolStrip toolstrip = ((SWF.ToolStripButton) Provider.Component).Owner;
75	}	75	toolstrip.InvokeSync (delegate {
76		76	button.PerformClick ();
77	private void PerformClick ()	77	});
78	{
79	SWF.ToolStrip toolstrip = ((SWF.ToolStripButton)Provider.Component).Owner;
80	if (toolstrip.InvokeRequired == true) {
81	toolstrip.BeginInvoke (new SWF.MethodInvoker (PerformClick));
82	return;
83	}
84	button.PerformClick ();
85	}	78	}
86	#endregion	79	#endregion
87		80

Lines 44-50 namespace Mono.UIAutomation.Winforms.Behaviors.ToolStripItem Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ToolStripItem/InvokeProviderBehavior.cs (-22 / +31 lines)
44	ToolStripItemProvider itemProvider;	44	ToolStripItemProvider itemProvider;
45		45
46	#endregion	46	#endregion
47		47
48	#region Constructor	48	#region Constructor
49		49
50	public InvokeProviderBehavior (ToolStripItemProvider provider)	50	public InvokeProviderBehavior (ToolStripItemProvider provider)
Lines 82-130 namespace Mono.UIAutomation.Winforms.Behaviors.ToolStripItem Link Here
82	if (((SWF.ToolStripItem)Provider.Component).Enabled == false)	82	if (((SWF.ToolStripItem)Provider.Component).Enabled == false)
83	throw new ElementNotEnabledException ();	83	throw new ElementNotEnabledException ();
84		84
85	PerformClick ();	85	SynchronizedPerformClick ();
86	}	86	}
87		87
88	#endregion	88	#endregion
89		89
90	#region Private Methods	90	#region Private Methods
91		91
92	private void PerformClick ()	92	private void SynchronizedPerformClick ()
93	{	93	{
94	SWF.ToolStripItem item = (SWF.ToolStripItem) Provider.Component;	94	SWF.ToolStripItem item = (SWF.ToolStripItem) Provider.Component;
95	if (item.Owner != null && item.Owner.InvokeRequired) {	95	if (item.Owner != null)
96	item.Owner.BeginInvoke (new SWF.MethodInvoker (PerformClick));	96	item.Owner.InvokeSync (delegate {
97	return;	97	PerformClick (item);
98	}	98	});
		99	else // Hopefully we shouldn't have any issue
		100	PerformClick (item);
		101	}
99		102
100	var currentParent = item.OwnerItem as SWF.ToolStripMenuItem;	103	private void PerformClick (SWF.ToolStripItem item)
		104	{
		105	SWF.ToolStrip currentParent = item.GetCurrentParent ();
101		106
102	// Invoking without a visible parent results in exceptions	107	// Invoking without a visible parent results in exceptions
103	if (currentParent != null && !currentParent.DropDown.Visible)	108	if (currentParent == null \|\| !currentParent.Visible)
104	return;	109	return;
105		110
106	var dropdown = item as SWF.ToolStripDropDownItem;
107	bool hide = false;
108	if (dropdown != null)
109	hide = dropdown.Pressed;
110
111	// Make sure selection changes, or else another item's	111	// Make sure selection changes, or else another item's
112	// dropdown menu might still appear.	112	// dropdown menu might still appear.
113	if (item.Owner != null)	113	if (item.Owner != null)
114	item.Select ();	114	item.Select ();
115		115
116	item.PerformClick ();
117
118	// PerformClick does _not_ show/hide the DropDown, so	116	// PerformClick does _not_ show/hide the DropDown, so
119	// we must do this manually. On Vista, clicking the	117	// we must do this manually. On Vista, clicking the
120	// button appears to both Show the drop down and	118	// button appears to both Show the drop down and
121	// Perform a click, so we emulate that behavior.	119	// Perform a click, so we emulate that behavior.
122	if (dropdown != null && !(item is SWF.ToolStripSplitButton)) {	120	if (item is SWF.ToolStripDropDownButton) {
123	if (hide)	121	SWF.ToolStripDropDownButton dropDown = (SWF.ToolStripDropDownButton) item;
124	dropdown.HideDropDown ();	122	if (!dropDown.Pressed) {
125	else	123	dropDown.ShowDropDown ();
126	dropdown.ShowDropDown ();	124	} else {
		125	dropDown.HideDropDown ();
		126	}
		127	} else if (item is SWF.ToolStripMenuItem) {
		128	SWF.ToolStripMenuItem menuItem = (SWF.ToolStripMenuItem) item;
		129	if (!menuItem.Pressed) {
		130	menuItem.ShowDropDown ();
		131	} else {
		132	menuItem.HideDropDown ();
		133	}
127	}	134	}
		135
		136	item.PerformClick ();
128	}	137	}
129		138
130	#endregion	139	#endregion

Lines 77-95 namespace Mono.UIAutomation.Winforms.Behaviors.ToolStripSplitButton Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ToolStripSplitButton/ExpandCollapseProviderBehavior.cs (-4 / +15 lines)
77	if (dropdown == null)	77	if (dropdown == null)
78	return ExpandCollapseState.Collapsed;	78	return ExpandCollapseState.Collapsed;
79		79
80	return dropdown.Visible ? ExpandCollapseState.Expanded	80	return Owner.InvokeSync (o => dropdown.Visible ? ExpandCollapseState.Expanded
81	: ExpandCollapseState.Collapsed;	81	: ExpandCollapseState.Collapsed
		82	);
82	}	83	}
83	}	84	}
84		85
85	public void Collapse ()	86	public void Collapse ()
86	{	87	{
87	((SWF.ToolStripSplitButton) Provider.Component).HideDropDown ();	88	Owner.InvokeSync (delegate {
		89	((SWF.ToolStripSplitButton) Provider.Component).HideDropDown ();
		90	});
88	}	91	}
89		92
90	public void Expand ()	93	public void Expand ()
91	{	94	{
92	((SWF.ToolStripSplitButton) Provider.Component).ShowDropDown ();	95	Owner.InvokeSync (delegate {
		96	((SWF.ToolStripSplitButton) Provider.Component).ShowDropDown ();
		97	});
		98	}
		99	#endregion
		100
		101	#region Private Properties
		102	private SWF.ToolStrip Owner {
		103	get { return ((SWF.ToolStripItem) Provider.Component).Owner; }
93	}	104	}
94	#endregion	105	#endregion
95	}	106	}

Lines 93-104 namespace Mono.UIAutomation.Winforms.Behaviors.TreeView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/TreeView/ExpandCollapeProviderBehavior.cs (-26 / +6 lines)
93	if (!treeView.Enabled)	93	if (!treeView.Enabled)
94	throw new ElementNotEnabledException ();	94	throw new ElementNotEnabledException ();
95		95
96	if (treeView != null && treeView.InvokeRequired) {	96	treeView.InvokeSync (delegate {
97	treeView.BeginInvoke (new SWF.MethodInvoker (PerformCollapse));	97	nodeProvider.TreeNode.Collapse ();
98	return;	98	});
99	}
100
101	PerformCollapse ();
102	}	99	}
103		100
104	public void Expand ()	101	public void Expand ()
Lines 110-122 namespace Mono.UIAutomation.Winforms.Behaviors.TreeView Link Here
110		107
111	if (!treeView.Enabled)	108	if (!treeView.Enabled)
112	throw new ElementNotEnabledException ();	109	throw new ElementNotEnabledException ();
113
114	if (treeView != null && treeView.InvokeRequired) {
115	treeView.BeginInvoke (new SWF.MethodInvoker (PerformExpand));
116	return;
117	}
118		110
119	PerformExpand ();	111	treeView.InvokeSync (delegate {
		112	nodeProvider.TreeNode.Expand ();
		113	});
120	}	114	}
121		115
122	public ExpandCollapseState ExpandCollapseState {	116	public ExpandCollapseState ExpandCollapseState {
Lines 131-149 namespace Mono.UIAutomation.Winforms.Behaviors.TreeView Link Here
131	}	125	}
132		126
133	#endregion	127	#endregion
134
135	#region Private Methods
136
137	private void PerformCollapse ()
138	{
139	nodeProvider.TreeNode.Collapse ();
140	}
141
142	private void PerformExpand ()
143	{
144	nodeProvider.TreeNode.Expand ();
145	}
146
147	#endregion
148	}	128	}
149	}	129	}