Attachment #304144 for bug #494034

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

Lines 296-303 FILES = \ Link Here

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




				// from ThemeWin32Classic.cs
				int borderSize = 8;
				int iconSize = 0;
				if (balloonWindow.InvokeSync (c => !(c.Icon == SWF.ToolTipIcon.None)))
				                                                                b => !(balloonWindow.Icon == SWF.ToolTipIcon.None)))
					iconSize = 16;
				if (iconSize == 0)
					return Rect.Empty;
				int imageX, imageY, imageWidth, imageHeight;
	
				Rect balloonRect 
					= (Rect) Provider.GetPropertyValue (AutomationElementIdentifiers.BoundingRectangleProperty.Id);
			

				imageY = (int) balloonRect.Y + borderSize;
				imageWidth = iconSize;
				imageHeight = iconSize;
	
				Rect imageRect = new Rect (imageX, imageY, imageWidth, imageHeight);
				balloonRect.Intersect (imageRect);
				return balloonRect;




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

			button.InvokeSync (delegate { button.PerformClick (); });
				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;
					PerformToggle (checkbox, 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))
			                                                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);
}




		public ExpandCollapseState ExpandCollapseState {
			get {
				SWF.ComboBox combobox = (SWF.ComboBox) Provider.Control;
				if (combobox.InvokeSync (c => c.DroppedDown))
				                                                c => c.DroppedDown))
					return ExpandCollapseState.Expanded;
				else
					return ExpandCollapseState.Collapsed;

		{
			SWF.ComboBox combobox = (SWF.ComboBox) Provider.Control;
			
			if (combobox.InvokeSync (c => !c.Enabled))
			                                                c => !c.Enabled))
				throw new ElementNotEnabledException ();
			
			combobox.InvokeSync (delegate {
				combobox.DroppedDown = false;
			});
		}

		{
			SWF.ComboBox combobox = (SWF.ComboBox) Provider.Control;
			
			if (combobox.InvokeSync (c => !c.Enabled))
			                                                c => !c.Enabled))
				throw new ElementNotEnabledException ();

			combobox.InvokeSync (delegate {
				combobox.DroppedDown = true;
			});
		}

Lines 71-78 namespace Mono.UIAutomation.Winforms.Behaviors.ComboBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ComboBox/ListBoxSelectionProviderBehavior.cs (-2 / +1 lines)
71		71
72	public override bool IsSelectionRequired {	72	public override bool IsSelectionRequired {
73	get {	73	get {
74	return Helper.SynchronizedGet<SWF.ComboBox, bool> ((SWF.ComboBox) Provider.Control,	74	return ((SWF.ComboBox) Provider.Control).InvokeSync (c => c.SelectedIndex != -1);
75	c => c.SelectedIndex != -1);
76	}	75	}
77	}	76	}
78		77

Lines 96-103 namespace Mono.UIAutomation.Winforms.Behaviors.ComboBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ComboBox/SelectionProviderBehavior.cs (-2 / +1 lines)
96		96
97	public virtual bool IsSelectionRequired {	97	public virtual bool IsSelectionRequired {
98	get {	98	get {
99	return Helper.SynchronizedGet<SWF.ComboBox, bool> ((SWF.ComboBox) Provider.Control,	99	return ((SWF.ComboBox) Provider.Control).InvokeSync (c => c.SelectedIndex != -1);
100	c => c.SelectedIndex != -1);
101	}	100	}
102	}	101	}
103		102




		#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;
			});
		}




	
		public bool CanMove {
			get {
				return form.InvokeSync (f => f.WindowState == SWF.FormWindowState.Normal);
				return Helper.SynchronizedGet<SWF.Form, bool> ((SWF.Form) Provider.Control,
				                                               f => f.WindowState == SWF.FormWindowState.Normal);
			}
		}

		public bool CanResize {
			get {
				switch (form.InvokeSync (f => f.FormBorderStyle)) {
				//switch (Helper.SynchronizedGet<SWF.Form, SWF.FormBorderStyle> ((SWF.Form) Provider.Control,
				//                                                               v => v.FormBorderStyle)) {
				switch (form.FormBorderStyle) {
				case SWF.FormBorderStyle.Fixed3D:
				case SWF.FormBorderStyle.FixedDialog:
				case SWF.FormBorderStyle.FixedSingle:

			if (!CanMove)
				throw new InvalidOperationException ("CanMove is false");

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

			if (!CanResize)
				throw new InvalidOperationException ("CanResize is false");

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




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

				break;
			}

			form.InvokeSync (delegate { form.WindowState = newState; });
				form.WindowState = newState;
			});
		}
		
		public void Close ()
		{
			form.InvokeSync (delegate { form.Close (); });
				form.Close ();
			});
		}
		
		public bool Minimizable {
			get { return form.InvokeSync (f => f.MinimizeBox); }
				//return Helper.SynchronizedGet<SWF.Form, bool> (form,
				return Helper.SynchronizedGet<SWF.Form, bool> ((SWF.Form) Provider.Control,
				                                               f => f.MinimizeBox);
			}
		}
		
		public bool Maximizable {
			get { return form.InvokeSync (f => f.MaximizeBox); }
				//return Helper.SynchronizedGet<SWF.Form, bool> (form,
				return Helper.SynchronizedGet<SWF.Form, bool> ((SWF.Form) Provider.Control,
				                                               f => f.MaximizeBox);
			}
		}
		
		public bool IsTopmost {
			get { return form.InvokeSync (f => f.TopMost); }
				//return Helper.SynchronizedGet<SWF.Form, bool> (form,
				return Helper.SynchronizedGet<SWF.Form, bool> ((SWF.Form) Provider.Control,
				                                               f => f.TopMost);
			}
		}
		
		public bool IsModal {
			get { return form.InvokeSync (f => f.Modal); }
				return Helper.SynchronizedGet<SWF.Form, bool> ((SWF.Form) Provider.Control,
//				return Helper.SynchronizedGet<SWF.Form, bool> (form,
				                                               f => f.Modal);
			}
		}
		
		public WindowInteractionState InteractionState {

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




				if (HorizontallyScrollable == false)
					return ScrollPatternIdentifiers.NoScroll;
				else {
					return hscrollbar.InvokeSync (c => {
						if (c.Maximum == 0)
						if (hscrollbar.Maximum == 0)
							return ScrollPatternIdentifiers.NoScroll;
						else
							return (double) ((c.Value * 100) / c.Maximum);
					});
				}
			}

				if (VerticallyScrollable == false)
					return ScrollPatternIdentifiers.NoScroll;
				else {
					return vscrollbar.InvokeSync (c => {
						if (c.Maximum == 0)
						if (vscrollbar.Maximum == 0)
							return ScrollPatternIdentifiers.NoScroll;
						else
							return (double) ((c.Value * 100) / c.Maximum);
					});
				}
			}

				if (horizontalPercent < 0 || horizontalPercent > 100)
					throw new ArgumentOutOfRangeException ();
				else {
					double maximum = hscrollbar.InvokeSync (h => h.Maximum);
					hscrollbar.InvokeSync (delegate {
						hscrollbar.Value = (int) ((horizontalPercent * maximum) / 100);
					});
				}
			}
			

			    if (verticalPercent < 0 || verticalPercent > 100)
					throw new ArgumentOutOfRangeException ();
				else {
					double maximum = vscrollbar.InvokeSync (v => v.Maximum);
					hscrollbar.InvokeSync (delegate {
						vscrollbar.Value = (int) ((verticalPercent * maximum) / 100);
					});
				}
			}
		}

			invoke
				= (Action<SWF.ScrollBar>) Delegate.CreateDelegate (typeof (Action<SWF.ScrollBar>), 
				                                                   methodInfo);

			scrollbar.InvokeSync (delegate { 
				invoke (scrollbar);
				invoke = null;
			});
			if (scrollbar.InvokeRequired == true) {
				scrollbar.BeginInvoke (new ScrollByAmountDelegate (PerformScrollByAmount),
				                       new object [] { scrollbar });
				return;
			}
			invoke (scrollbar);
			invoke = null;
		}
		
		private void PerformScrollByPercent (SWF.ScrollBar scrollbar, int value)
		{
			if (scrollbar.InvokeRequired == true) {
				scrollbar.BeginInvoke (new ScrollByPercentDelegate (PerformScrollByPercent),
				                       new object [] { scrollbar, value });
				return;
			}
			scrollbar.Value = value;
		}

		#endregion

Lines 123-129 namespace Mono.UIAutomation.Winforms.Behaviors.Generic Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/Generic/SelectionItemProviderBehavior.cs (-2 / +2 lines)
123	if (IsSelected)	123	if (IsSelected)
124	return;	124	return;
125		125
126	Helper.SynchronizedSet (itemProvider.ContainerControl, delegate {	126	itemProvider.ContainerControl.InvokeSync (delegate {
127	itemProvider.Select ();	127	itemProvider.Select ();
128	});	128	});
129	}	129	}
Lines 163-169 namespace Mono.UIAutomation.Winforms.Behaviors.Generic Link Here
163		163
164	private void PerformUnselect ()	164	private void PerformUnselect ()
165	{	165	{
166	Helper.SynchronizedSet (itemProvider.ContainerControl, delegate {	166	itemProvider.ContainerControl.InvokeSync (delegate {
167	itemProvider.Unselect ();	167	itemProvider.Unselect ();
168	});	168	});
169	}	169	}




		#region IHypertext Specialization
		
		public int NumberOfLinks { 
			get { return linkLabel.InvokeSync (c => c.Links.Count); }
				return Helper.SynchronizedGet<SWF.LinkLabel, int> (linkLabel,
				                                                    l=> l.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;
			});
		}
		

			if (!Enabled (index))
				throw new ElementNotEnabledException ();
			
			linkLabel.InvokeSync (c => {
				if (index >= c.Links.Count || index < 0)
				if (index >= linkLabel.Links.Count || index < 0)
					return;
	
				MethodInfo methodInfo = typeof (SWF.LinkLabel).GetMethod ("OnLinkClicked",

						 methodInfo);
	
				SWF.LinkLabelLinkClickedEventArgs args 
					= new SWF.LinkLabelLinkClickedEventArgs (c.Links [index],
					                                         SWF.MouseButtons.Left);
				invokeMethod (c, args);
			});
		}
		

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListBox/SelectionProviderBehavior.cs (-3 / +2 lines)
95	get {	95	get {
96	SWF.ListBox listBoxControl = (SWF.ListBox) Provider.Control;	96	SWF.ListBox listBoxControl = (SWF.ListBox) Provider.Control;
97		97
98	return Helper.SynchronizedGet<SWF.ListBox, bool> (listBoxControl,	98	return listBoxControl.InvokeSync (c => c.SelectionMode == SWF.SelectionMode.MultiExtended
99	l => l.SelectionMode == SWF.SelectionMode.MultiExtended	99	\|\| c.SelectionMode == SWF.SelectionMode.MultiSimple);
100	\|\| l.SelectionMode == SWF.SelectionMode.MultiSimple);
101	}	100	}
102	}	101	}
103		102

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListItem/ScrollItemProviderBehavior.cs (-1 / +1 lines)
70	public void ScrollIntoView ()	70	public void ScrollIntoView ()
71	{	71	{
72	IListProvider itemProvider = ((ListItemProvider) Provider).ListProvider;	72	IListProvider itemProvider = ((ListItemProvider) Provider).ListProvider;
73	Helper.SynchronizedSet (itemProvider.Control, delegate {	73	itemProvider.Control.InvokeSync (delegate {
74	itemProvider.ScrollItemIntoView ((ListItemProvider) Provider);	74	itemProvider.ScrollItemIntoView ((ListItemProvider) Provider);
75	});	75	});
76	}	76	}

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListItem/ToggleProviderBehavior.cs (-1 / +1 lines)
79	{	79	{
80	ListItemProvider provider = (ListItemProvider) Provider;	80	ListItemProvider provider = (ListItemProvider) Provider;
81		81
82	Helper.SynchronizedSet (provider.ListProvider.Control, delegate {	82	provider.ListProvider.Control.InvokeSync (delegate {
83	provider.ListProvider.ToggleItem (provider);	83	provider.ListProvider.ToggleItem (provider);
84	});	84	});
85	}	85	}





		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)) {
			                                                l => l.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 => {
				                                                  delegate {
					if (viewGroupProvider.ListView.View == SWF.View.Details)
						return c.Columns.Count;
					else {
						int maxColums = c.UIAColumns;
						int itemsInGroup = ItemsInGroupCount ();
		
						if (itemsInGroup < maxColums)


		private int ItemsInGroupCount ()
		{
			return viewGroupProvider.ListView.InvokeSync (c => {
			                                                  delegate {
				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;

Lines 85-91 namespace Mono.UIAutomation.Winforms.Behaviors.ListView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListView/ListItemCheckBoxToggleProviderBehavior.cs (-1 / +1 lines)
85	{	85	{
86	ListItemProvider provider = checkboxProvider.ItemProvider;	86	ListItemProvider provider = checkboxProvider.ItemProvider;
87		87
88	Helper.SynchronizedSet (provider.ListProvider.Control, delegate {	88	provider.ListProvider.Control.InvokeSync (delegate {
89	provider.ListProvider.ToggleItem (provider);	89	provider.ListProvider.ToggleItem (provider);
90	});	90	});
91	}	91	}

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListView/ListItemClipboardProviderBehavior.cs (-1 / +1 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	Helper.SynchronizedSet (viewItem.ListView, delegate {	80	viewItem.ListView.InvokeSync (delegate {
81	viewItem.Text = newValue;	81	viewItem.Text = newValue;
82	});	82	});
83	}	83	}




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




		}
		
		public bool IsReadOnly {
			get { return listView.InvokeSync (l => !l.LabelEdit); }
				return Helper.SynchronizedGet<SWF.ListView, bool> (listView,
				                                                    l => !l.LabelEdit);
			}
		}
		
		public string Value {
			get {
				return listView.InvokeSync (c => {
					int indexOf = c.Columns.IndexOf (columnHeader);
					int indexOf = listView.Columns.IndexOf (columnHeader);
	
					if (indexOf < 0 || indexOf >= listViewItem.SubItems.Count)
						return string.Empty;




				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;

					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;




			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);
						return view.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;
								}

		}
		
		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); }
				return Helper.SynchronizedGet<SWF.ListView, bool> (viewItem.ListView,
				                                                   v => !v.LabelEdit);
			}
		}
		
		public string Value {

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListView/SelectionProviderBehavior.cs (-2 / +1 lines)
95	public bool CanSelectMultiple {	95	public bool CanSelectMultiple {
96	get {	96	get {
97	SWF.ListView listview = (SWF.ListView) Provider.Control;	97	SWF.ListView listview = (SWF.ListView) Provider.Control;
98	return Helper.SynchronizedGet<SWF.ListView, bool> (listview,	98	return listview.InvokeSync (c => c.MultiSelect);
99	l => l.MultiSelect);
100	}	99	}
101	}	100	}
102		101




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

			maskedTextBox.InvokeSync (delegate {

				System.ComponentModel.MaskedTextProvider prov
					= maskedTextBox.MaskedTextProvider;


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

			maskedTextBox.InvokeSync (delegate {
				// MaskedTextProvider.RemoveAt does not work for this.
				System.ComponentModel.MaskedTextProvider prov
					= maskedTextBox.MaskedTextProvider;




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

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

		public void CommitEdit ()
		{
			numericUpDown.InvokeSync (delegate {
				decimal value = decimal.Parse (numericUpDown.Text);
				if (value < numericUpDown.Minimum)
					value = numericUpDown.Minimum;




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

		public double Value {
			get { return numericUpDown.InvokeSync (c => (double) c.Value); }
				return Helper.SynchronizedGet<SWF.NumericUpDown, double> (numericUpDown,
				                                                           n => (double) numericUpDown.Value);
			}
		}
		
		public void SetValue (double value)

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

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




#region IEmbeddedImageProvider Interface
		public Rect Bounds {
			get {
				return control.InvokeSync (c => {
						if (c.Image == null)
						if (control.Image == null)
							return Rect.Empty;

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

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

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ProgressBar/RangeValueProviderBehavior.cs (-2 / +2 lines)
101	#region IRangeValueProvider Members	101	#region IRangeValueProvider Members
102		102
103	public double Value {	103	public double Value {
104	get { return Helper.SynchronizedGet<SWF.ProgressBar, double> (progressBar, p => p.Value); }	104	get { return progressBar.InvokeSync (p => p.Value); }
105	}	105	}
106		106
107	public bool IsReadOnly {	107	public bool IsReadOnly {
Lines 129-135 namespace Mono.UIAutomation.Winforms.Behaviors.ProgressBar Link Here
129	if (value < Minimum \|\| value > Maximum)	129	if (value < Minimum \|\| value > Maximum)
130	throw new ArgumentOutOfRangeException ();	130	throw new ArgumentOutOfRangeException ();
131		131
132	Helper.SynchronizedSet (progressBar, delegate {	132	progressBar.InvokeSync (delegate {
133	progressBar.Value = (int) value;	133	progressBar.Value = (int) value;
134	});	134	});
135	}	135	}

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/RadioButton/SelectionItemProviderBehavior.cs (-1 / +1 lines)
120		120
121	public void Select ()	121	public void Select ()
122	{	122	{
123	Helper.SynchronizedSet (radioButton, delegate {	123	radioButton.InvokeSync (delegate {
124	radioButton.Checked = true;	124	radioButton.Checked = true;
125	});	125	});
126	}	126	}




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

			string methodName = string.Empty;

				Action<SWF.ScrollBar> invokeMethod
					= (Action<SWF.ScrollBar>) Delegate.CreateDelegate (typeof (Action<SWF.ScrollBar>), 
					                                                   methodInfo);
				provider.ScrollBarContainer.InvokeSync (delegate {
					invokeMethod (provider.ScrollBarContainer);
				});
			}
		}
		




			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);
					scrollbar, 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 IDockProvider Members
		
		public DockPosition DockPosition {
			get { return splitContainer.InvokeSync (s => Helper.GetDockPosition (s.Dock)); }
				return Helper.SynchronizedGet<SWF.SplitContainer, DockPosition> (
					splitContainer, s => Helper.GetDockPosition (s.Dock)
				);
			}
		}
		
		public void SetDockPosition (DockPosition dockPosition)
		{
			//throw new InvalidOperationException ();
			
			splitContainer.InvokeSync (delegate {
				splitContainer.Dock = Helper.GetDockStyle (dockPosition);
			});
		}

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




			if (value < Minimum || value > Maximum)
				throw new ArgumentOutOfRangeException ();
			
			splitcontainer.InvokeSync (delegate {
				splitcontainer.SplitterDistance = (int) value;
			});
		}
		
		public bool IsReadOnly {
			get { return splitcontainer.InvokeSync (s => !s.Enabled || !s.Visible); }
				return Helper.SynchronizedGet<SWF.SplitContainer, bool> (
					(SWF.SplitContainer) Provider.Control, s => !s.Enabled || !s.Visible
				);
			}
		}
		
		public double LargeChange {

		}
		
		public double Maximum {
			get { return splitcontainer.InvokeSync (s => s.Width - (s.SplitterWidth + s.Panel2MinSize)); }
				return Helper.SynchronizedGet<SWF.SplitContainer, double> (
					(SWF.SplitContainer) Provider.Control, s => s.Width - (s.SplitterWidth + s.Panel2MinSize)
				);
			}
		}
		
		public double Minimum {
			get { return splitcontainer.InvokeSync (s => s.Panel1MinSize); }
				return Helper.SynchronizedGet<SWF.SplitContainer, double> (
					(SWF.SplitContainer) Provider.Control, s => s.Panel1MinSize
				);
			}
		}
		
		public double SmallChange {

		}
		
		public double Value {
			get { return splitcontainer.InvokeSync (s => s.SplitterDistance); }
				return Helper.SynchronizedGet<SWF.SplitContainer, double> (
					(SWF.SplitContainer) Provider.Control, s => s.SplitterDistance
				);
			}
		}
		
		#endregion 




		}
		
		public bool CanResize {
			get { return splitContainer.InvokeSync (s => !(s.Panel1Collapsed || s.Panel2Collapsed)); }
				return Helper.SynchronizedGet<SWF.SplitContainer, bool> (
					splitContainer,
					s => !(s.Panel1Collapsed || s.Panel2Collapsed)
				);
			}
		}
		
		public bool CanRotate {

			if (!CanResize)
				throw new InvalidOperationException ();

			splitContainer.InvokeSync (delegate {
				if (splitContainer.Orientation == SWF.Orientation.Horizontal)
					splitContainer.Panel1.Width = (int) width;
				else

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

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

Lines 101-109 namespace Mono.UIAutomation.Winforms.Behaviors.StatusBar Link Here

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

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/StatusStrip/GridProviderBehavior.cs (-5 / +1 lines)
86	}	86	}
87		87
88	public int ColumnCount {	88	public int ColumnCount {
89	get {	89	get { return statusStrip.InvokeSync (s => s.Items.Count); }
90	return Helper.SynchronizedGet<SWF.StatusStrip, int> (
91	statusStrip, s => s.Items.Count
92	);
93	}
94	}	90	}
95		91
96	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 {

		}

		public bool HorizontallyScrollable {
			get { return tabControl.InvokeSync (t => t.ShowSlider); }
				return Helper.SynchronizedGet<SWF.TabControl, bool> (
					tabControl, t => t.ShowSlider
				);
			}
		}

		public bool VerticallyScrollable {

Lines 112-118 namespace Mono.UIAutomation.Winforms.Behaviors.TabPage Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/TabPage/SelectionItemProviderBehavior.cs (-1 / +1 lines)
112	return;	112	return;
113	}	113	}
114		114
115	Helper.SynchronizedSet (pageProvider.TabControlProvider.Control, delegate {	115	pageProvider.TabControlProvider.Control.InvokeSync (delegate {
116	pageProvider.TabControlProvider.SelectItem (pageProvider);	116	pageProvider.TabControlProvider.SelectItem (pageProvider);
117	});	117	});
118	}	118	}




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


		public bool SetCaretOffset (int offset)
		{
			return Provider.Control.InvokeSync (c => {
				if (offset < 0)
					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;
				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;
			});
		}

		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;

				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 ());
						(SWF.MaskedTextBox) TextBoxBase, t => t.MaskedTextProvider.ToDisplayString ()
					);
				} else {
					return TextBoxBase.InvokeSync (t => t.Text);
						TextBoxBase, t => t.Text
					);
				}
			}
			set {
				SWF.TextBoxBase textBoxBase = TextBoxBase;
				textBoxBase.InvokeSync (delegate { textBoxBase.Text = value; });
				});
			}
		}






		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);

		
		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 (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); }
		}
	}
}




		
		public bool IsReadOnly {
			get {
				return ((SWF.TextBoxBase) Provider.Control).InvokeSync (c => c.ReadOnly 
				                                                         || !c.Enabled);
					t => t.ReadOnly || !t.Enabled
				);
			}
		}
		

			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 ();
							c => { return mtp.ToDisplayString (); }
						);
					}
				}

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


			if (IsReadOnly)
				throw new ElementNotEnabledException ();

			Provider.Control.InvokeSync (delegate {
				delegate {
					int maxLength = ((TextBoxProvider) Provider).MaxLength;
					if (maxLength > 0
					    && value.Length > maxLength) {

Lines 83-90 namespace Mono.UIAutomation.Winforms.Behaviors.ToolBar Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ToolBar/ToolBarButtonExpandCollapseProviderBehavior.cs (-3 / +2 lines)
83	if (menu == null)	83	if (menu == null)
84	return ExpandCollapseState.Collapsed;	84	return ExpandCollapseState.Collapsed;
85		85
86	return Helper.SynchronizedGet<SWF.ToolBar, ExpandCollapseState> (	86	return toolBar.InvokeSync (t => toolBarButton.Pushed ? ExpandCollapseState.Expanded
87	toolBar, t => toolBarButton.Pushed ? ExpandCollapseState.Expanded
88	: ExpandCollapseState.Collapsed	87	: ExpandCollapseState.Collapsed
89	);	88	);
90	}	89	}
Lines 112-118 namespace Mono.UIAutomation.Winforms.Behaviors.ToolBar Link Here
112		111
113	private void PerformExpandCollapse ()	112	private void PerformExpandCollapse ()
114	{	113	{
115	Helper.SynchronizedSet (toolBar, delegate {	114	toolBar.InvokeSync (delegate {
116	SWF.ContextMenu menu = toolBarButton.DropDownMenu as SWF.ContextMenu;	115	SWF.ContextMenu menu = toolBarButton.DropDownMenu as SWF.ContextMenu;
117	if (menu == null)	116	if (menu == null)
118	return;	117	return;




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

			toolBar.InvokeSync (delegate {
				toolBar.UIAPerformClick (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);
			});
		}

Lines 72-78 namespace Mono.UIAutomation.Winforms.Behaviors.ToolStripButton Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ToolStripButton/InvokeProviderBehavior.cs (-1 / +1 lines)
72	throw new ElementNotEnabledException ();	72	throw new ElementNotEnabledException ();
73		73
74	SWF.ToolStrip toolstrip = ((SWF.ToolStripButton) Provider.Component).Owner;	74	SWF.ToolStrip toolstrip = ((SWF.ToolStripButton) Provider.Component).Owner;
75	Helper.SynchronizedSet (toolstrip, delegate {	75	toolstrip.InvokeSync (delegate {
76	button.PerformClick ();	76	button.PerformClick ();
77	});	77	});
78	}	78	}




		public ToggleState ToggleState {
			get {
				SWF.CheckState state =
					Owner.InvokeSync (delegate { return button.CheckState; });
						Owner, delegate { return button.CheckState; }
					);

				switch (state) {
				case SWF.CheckState.Checked:

				throw new ElementNotEnabledException ();

			SWF.CheckState state =
				Owner.InvokeSync (delegate { return button.CheckState; });
					Owner, delegate { return button.CheckState; }
				);

			switch (state) {
			case SWF.CheckState.Checked:

#region Private Methods
		private void PerformToggle (SWF.ToolStripButton button, SWF.CheckState state)
		{
			Owner.InvokeSync (delegate {
				button.CheckState = state;
			});
		}

		private SWF.ToolStripButton button;
#endregion
	}

	delegate void PerformToggleDelegate (SWF.ToolStripButton button, SWF.CheckState state);
}

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ToolStripItem/InvokeProviderBehavior.cs (-1 / +1 lines)
93	{	93	{
94	SWF.ToolStripItem item = (SWF.ToolStripItem) Provider.Component;	94	SWF.ToolStripItem item = (SWF.ToolStripItem) Provider.Component;
95	if (item.Owner != null)	95	if (item.Owner != null)
96	Helper.SynchronizedSet (item.Owner, delegate {	96	item.Owner.InvokeSync (delegate {
97	PerformClick (item);	97	PerformClick (item);
98	});	98	});
99	else // Hopefully we shouldn't have any issue	99	else // Hopefully we shouldn't have any issue




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

				return Owner.InvokeSync (o => dropdown.Visible ? ExpandCollapseState.Expanded
					Owner, 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 ();
			});
		}

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/TrackBar/ButtonInvokeProviderBehavior.cs (-2 / +2 lines)
84		84
85	public void Invoke ()	85	public void Invoke ()
86	{	86	{
87	if (!Provider.Control.Enabled)	87	if (Provider.Control.InvokeSync (c => !c.Enabled))
88	throw new ElementNotEnabledException ();	88	throw new ElementNotEnabledException ();
89		89
90	Helper.SynchronizedSet (Provider.Control, delegate {	90	Provider.Control.InvokeSync (delegate {
91	if (provider.Orientation == TrackBarProvider.TrackBarButtonOrientation.LargeBack)	91	if (provider.Orientation == TrackBarProvider.TrackBarButtonOrientation.LargeBack)
92	((SWF.TrackBar)Provider.Control).LargeDecrement ();	92	((SWF.TrackBar)Provider.Control).LargeDecrement ();
93	else if (provider.Orientation == TrackBarProvider.TrackBarButtonOrientation.LargeForward)	93	else if (provider.Orientation == TrackBarProvider.TrackBarButtonOrientation.LargeForward)




			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); }
				return Helper.SynchronizedGet<SWF.TrackBar, bool> (
					trackbar, t => !t.Enabled || !t.Visible
				);
			}
		}
		
		public double LargeChange {
			get { return trackbar.InvokeSync (t => t.LargeChange); }
				return Helper.SynchronizedGet<SWF.TrackBar, double> (
					trackbar, t => t.LargeChange
				);
			}
		}
		
		public double Maximum {
			get { return trackbar.InvokeSync (t => t.Maximum); }
				return Helper.SynchronizedGet<SWF.TrackBar, double> (
					trackbar, t => t.Maximum
				);
			}
		}
		
		public double Minimum {
			get { return trackbar.InvokeSync (t => t.Minimum); }
				return Helper.SynchronizedGet<SWF.TrackBar, double> (
					trackbar, t => t.Minimum
				);
			}
		}
		
		public double SmallChange {
			get { return trackbar.InvokeSync (t => t.SmallChange); }
				return Helper.SynchronizedGet<SWF.TrackBar, double> (
					trackbar, t => t.SmallChange
				);
			}
		}
		
		public double Value {
			get { return trackbar.InvokeSync (t => t.Value); }
				return Helper.SynchronizedGet<SWF.TrackBar, double> (
					trackbar, t => t.Value
				);
			}
		}
		
		#endregion 




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

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

Lines 69-75 namespace Mono.UIAutomation.Winforms.Behaviors.UpDownBase Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/UpDownBase/ButtonInvokeProviderBehavior.cs (-1 / +1 lines)
69		69
70	public void Invoke ()	70	public void Invoke ()
71	{	71	{
72	Helper.SynchronizedSet (provider.UpDownBase, delegate {	72	provider.UpDownBase.InvokeSync (delegate {
73	if (provider.Orientation == UpDownBaseProvider.UpDownBaseButtonOrientation.Forward)	73	if (provider.Orientation == UpDownBaseProvider.UpDownBaseButtonOrientation.Forward)
74	provider.UpDownBase.UpButton ();	74	provider.UpDownBase.UpButton ();
75	else if (provider.Orientation == UpDownBaseProvider.UpDownBaseButtonOrientation.Backward)	75	else if (provider.Orientation == UpDownBaseProvider.UpDownBaseButtonOrientation.Backward)




		#region IValueProvider Members
		
		public bool IsReadOnly {
			get { return upDownBase.InvokeSync (c => c.ReadOnly); }
				return Helper.SynchronizedGet<SWF.UpDownBase, bool> (
					(SWF.UpDownBase) Provider.Control, u => u.ReadOnly
				);
			}
		}
		
		public string Value {
			get { return upDownBase.InvokeSync (c => c.Text); }
				return Helper.SynchronizedGet<SWF.UpDownBase, string> (
					(SWF.UpDownBase) Provider.Control, u => u.Text
				);
			}
		}
		
		public void SetValue (string value)
		{
			if (upDownBase.InvokeSync (c => !c.Enabled || c.ReadOnly))
				throw new ElementNotEnabledException ();

			upDownBase.InvokeSync (delegate { upDownBase.Text = value; });
				upDownBase.Text = value;
			});
		}
		
		#endregion




		
		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




					return;
				
				bool newValue = val ?? false;
//				Helper.DelegateQueue.Get ().Enqueue (delegate {
//				System.Threading.ThreadPool.QueueUserWorkItem (v => {
				
				AutomationPropertyChangedEventArgs args 
					= new AutomationPropertyChangedEventArgs (property,
					                                          !newValue,
					                                          newValue);
				AutomationInteropProvider.RaiseAutomationPropertyChangedEvent (Provider, 
				                                                               args);
//				});
			}
		}
		




		protected void RaiseAutomationEvent ()
		{
			if (AutomationInteropProvider.ClientsAreListening == true) {
//				Helper.DelegateQueue.Get ().Enqueue (delegate {
//				System.Threading.ThreadPool.QueueUserWorkItem (v => {
					AutomationEventArgs args = 
						new AutomationEventArgs (Event);
					AutomationInteropProvider.RaiseAutomationEvent (Event, 
					                                                Provider, 
					                                                args);
//				});
			}
		}
		




				object newValue = GetNewPropertyValue ();

				if (object.Equals (OldValue, newValue) == false) {
					AutomationPropertyChangedEventArgs args =					
						new AutomationPropertyChangedEventArgs (Property,
						                                        OldValue,
						                                        newValue);
					AutomationInteropProvider.RaiseAutomationPropertyChangedEvent (Provider, 
					                                                               args);
					OldValue = newValue;
							                                        newValue);
						AutomationInteropProvider.RaiseAutomationPropertyChangedEvent (Provider, 
						                                                               args);
					});
				}
			}
		}

Lines 66-72 namespace Mono.UIAutomation.Winforms.Events.ComboBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/ComboBox/ListItemSelectionItemPatternElementSelectedEvent.cs (-1 / +1 lines)
66	{	66	{
67	ListItemProvider provider = (ListItemProvider) Provider;	67	ListItemProvider provider = (ListItemProvider) Provider;
68		68
69	if (provider.Index == ((SWF.ComboBox) provider.Control).SelectedIndex)	69	if (provider.Index == ((SWF.ComboBox) provider.Control).InvokeSync (c => c.SelectedIndex))
70	RaiseAutomationEvent ();	70	RaiseAutomationEvent ();
71	}	71	}
72		72

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	}





				
				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);
//					});
				}
			}
		}




<Project name="Mono.UIAutomation.Winforms" fileversion="2.0" language="C#" DefaultNamespace="Mono.UIAutomation.Winforms" UseParentDirectoryAsNamespace="True" clr-version="Net_2_0" targetFramework="3.5" ctype="DotNetProject">
  <Configurations active="Debug">
    <Configuration name="Debug" ctype="DotNetProjectConfiguration">
      <Output directory="bin/Debug" signAssembly="True" assemblyKeyFile="../mono-uia.snk" assembly="UIAutomationWinforms" />

    <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/DataGridView/DataItemChildHasKeyboardFocusPropertyEvent.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms.Behaviors/DataGrid/DataItemEditSelectionItemProviderBehavior.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms.Events/DataGrid/DataItemEditSelectionItemPatternIsSelectedEvent.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms.Behaviors/ListView/ListItemInvokeProviderBehavior.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms.Behaviors/ToolStripButton/ToggleProviderBehavior.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms.Events/DateTimePicker/CheckboxAutomationHasKeyboardFocusPropertyEvent.cs" subtype="Code" buildaction="Compile" />
    <File name="Mono.UIAutomation.Winforms.Events/DateTimePicker/PartAutomationHasKeyboardFocusPropertyEvent.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" />
  </Contents>
  <References>
    <ProjectReference type="Gac" localcopy="True" refto="System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />

    <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" />

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/BalloonWindowProvider.cs (-2 / +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 Helper.SynchronizedGet<NotifyIcon.BalloonWindow, string> (balloon,	78	return balloon.InvokeSync (c => c.AccessibleDescription ?? c.Title);
79	s => balloon.AccessibleDescription ?? balloon.Title);
80	else if (propertyId == AutomationElementIdentifiers.IsNotifyIconProperty.Id)	79	else if (propertyId == AutomationElementIdentifiers.IsNotifyIconProperty.Id)
81	return true;	80	return true;
82	else	81	else

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/CheckedListBoxProvider.cs (-3 / +2 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	Helper.SynchronizedSet (checkedListBox, delegate {	55	checkedListBox.InvokeSync (delegate {
56	bool chcked = checkedListBox.GetItemChecked (item.Index);	56	bool chcked = checkedListBox.GetItemChecked (item.Index);
57	checkedListBox.SetItemChecked (item.Index, !chcked);	57	checkedListBox.SetItemChecked (item.Index, !chcked);
58	});	58	});
Lines 65-72 namespace Mono.UIAutomation.Winforms Link Here
65	SWF.CheckedListBox checkedListBox = (SWF.CheckedListBox) Control;	65	SWF.CheckedListBox checkedListBox = (SWF.CheckedListBox) Control;
66		66
67	SWF.CheckState state	67	SWF.CheckState state
68	= Helper.SynchronizedGet<SWF.CheckedListBox, SWF.CheckState> (checkedListBox,	68	= checkedListBox.InvokeSync (c => c.GetItemCheckState (item.Index));
69	s => checkedListBox.GetItemCheckState (item.Index));
70	switch (state) {	69	switch (state) {
71	case SWF.CheckState.Checked:	70	case SWF.CheckState.Checked:
72	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))
			                                                        b => comboboxControl.DropDownStyle == SWF.ComboBoxStyle.DropDown))
				return false;
			else
				return base.GetProviderPropertyValue (propertyId);

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

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

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


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

			public override int IndexOfObjectItem (object objectItem)
			{
				return comboboxControl.InvokeSync (c => c.Items.IndexOf (objectItem));
				                                                  v => comboboxControl.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});
						}
					});

					// 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;
					});
			}

				if (!ContainsItem (item))
					return false;
				else
					return comboboxControl.InvokeSync (c => {
						return item.Index == c.SelectedIndex; });
						return item.Index == comboboxControl.SelectedIndex; });
//					                                                   v => item.Index == v.SelectedIndex);
			}

			public override void InitializeChildControlStructure ()

				comboboxControl.Items.UIACollectionChanged += OnCollectionChanged;

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

			                                             int propertyId)
			{
				if (propertyId == AutomationElementIdentifiers.NameProperty.Id)
					return comboboxControl.InvokeSync (c => c.GetItemText (item.ObjectItem));
					                                                     v => comboboxControl.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);
					                                                   b => comboboxControl.Focused && item.Index == comboboxControl.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);
						                                                                         b => comboboxControl.Bounds);
					else
						bounds = ListBoxControl.InvokeSync (c => c.Bounds);
						                                                                          b => ListBoxControl.Bounds);

					int itemHeight = comboboxControl.InvokeSync (c => c.GetItemHeight (0));// TODO: always true?
					rectangle.Height = comboboxControl.InvokeSync (c => c.GetItemHeight (index));
					rectangle.Height = Helper.SynchronizedGet<SWF.ComboBox, int> (comboboxControl,
					                                                              i => comboboxControl.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;

					// 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);




					Helper.RaiseStructureChangedEvent (StructureChangeType.ChildRemoved,
					                                   provider);
				}
				Helper.DelegateQueue.Get ().Quit ();
			};
			
			// FIXME: FormAdded is fired too frequently (such as

			if (formProviders.ContainsKey (f))
				return;

//			Helper.SynchronizedSet (f, delegate {

			FormProvider provider = (FormProvider)
				ProviderFactory.GetProvider (f, true);


				provider.Navigation = NavigationFactory.CreateNavigation (provider);
				provider.Navigation.Initialize ();

				Helper.DelegateQueue.Get ().Enqueue (delegate {
				
				// TODO: Fill in rest of eventargs
				Helper.RaiseStructureChangedEvent (StructureChangeType.ChildAdded,
				                                   provider);
				provider.InitializeChildControlStructure ();
				});
			} else {
				Console.WriteLine ("is child dialog..: {0}", Helper.DelegateQueue.Get ().Count);
				FormProvider ownerProvider 
					= (FormProvider) ProviderFactory.FindProvider (f.Owner);
				ownerProvider.AddChildProvider (provider);
			}
//			});
		}
		
#endregion




			
			// 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))
			                                        b => x > form.Width || y > form.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)) {
				if (control.Focused) {
					// TODO: Necessary to delve into child control
					// for focused element?
					

				alreadyClosed = true;

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


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




			children = new List<FragmentControlProvider> ();
			componentChildren = new List<Component> ();

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

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

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

		void HandleContextMenuStripChanged (object sender, EventArgs e)

				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;

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

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


				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;

		{
			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




// 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>

			if (control == null)
				return Rect.Empty;
			else {
//				SWF.Control c = control;
				return control.InvokeSync (c => {
					if (!c.Visible)
						return Rect.Empty;
					else if (controlIsParent)
						return Helper.RectangleToRect (c.RectangleToScreen (bounds));
					else if (c.Parent == null || c.TopLevelControl == null)
						return Helper.RectangleToRect (bounds);
					else {
						if (c.FindForm () == c.Parent)
							return Helper.RectangleToRect (c.TopLevelControl.RectangleToScreen (bounds));
						else
							return Helper.RectangleToRect (c.Parent.RectangleToScreen (bounds));
					}
				});
			}
		}

		internal static Rect GetToolStripItemScreenBounds (SWF.ToolStripItem item)

			if (item.Owner == null)
				return item.Bounds;
			else
				return item.Owner.InvokeSync (c => c.RectangleToScreen (item.Bounds));
				return item.Owner.RectangleToScreen (item.Bounds);
		}

		internal static object GetClickablePoint (SimpleControlProvider provider)

		                                          Rectangle headerBounds,
		                                          IScrollBehaviorObserver observer)
		{
			Rectangle listViewRectangle = containerControl.InvokeSync (c => c.Bounds);
			                                                                              b => containerControl.Bounds);
			if (visibleHeader) {
				listViewRectangle.Y += headerBounds.Height;
				listViewRectangle.Height -= headerBounds.Height;

			if (observer.VerticalScrollBar.Visible)
				listViewRectangle.Width -= observer.VerticalScrollBar.Width;
			
			SWF.Control parent = containerControl.InvokeSync (c => c.Parent);
				= Helper.SynchronizedGet<SWF.Control, SWF.Control> (containerControl, p => containerControl.Parent);
			Rect screen
				= parent.InvokeSync (c => Helper.RectangleToRect (c.RectangleToScreen (listViewRectangle)));
				                                             r => Helper.RectangleToRect (parent.RectangleToScreen (listViewRectangle)));
			return !itemBounds.IntersectsWith (screen);
		}


			int imageY;
			int imageWidth;
			int imageHeight;
			int width = buttonBase.InvokeSync (c => c.Width);
			int height = buttonBase.InvokeSync (c => c.Height);

			image = buttonBase.InvokeSync (c => {
				if (c.ImageIndex != -1)
					return c.ImageList.Images [c.ImageIndex];
				else
					return c.Image;
			});
			
			if (image == null)

			imageWidth = image.Width;
			imageHeight = image.Height;
		
			switch (buttonBase.InvokeSync (c => c.ImageAlign)) {
				case ContentAlignment.TopLeft: {
					imageX = 5;
					imageY = 5;

				else
					runtimeId = provider.GetRuntimeId ();

				StructureChangedEventArgs invalidatedArgs 
					= new StructureChangedEventArgs (type, runtimeId);
				AutomationInteropProvider.RaiseStructureChangedEvent (provider, 
				                                                      invalidatedArgs);
					AutomationInteropProvider.RaiseStructureChangedEvent (provider, 
					                                                      invalidatedArgs);
//				});
			}
		}
		

			return s;
		}

		private static Thread invokeThread;
		private static object invokeThreadLock = new object ();
//		private static object lockObj = new object ();
		
		private static Thread InvokeThread {
			// FIXME: Remove getter
			get {
				lock (invokeThreadLock) {
					return invokeThread;
				}
			}
			
			set {
				lock (invokeThreadLock) {
					invokeThread = Thread.CurrentThread;
				}
			}
		}

		internal static Return SynchronizedGet<Subject, Return> (Subject subject, Func<Subject, Return> verb)
			where Subject : SWF.Control
		{
			lock (lockObject) {
				// If is being used already in a different thread
				if (Interlocked.CompareExchange (ref Counter, 1, 1) == 1
				    && (InvokeThread != null && InvokeThread != Thread.CurrentThread))  {
					Console.WriteLine ("ya esta siendo usado...");
					Monitor.Wait (lockObject);
					InvokeThread = null;
				}
			}
			
			if (subject.InvokeRequired && subject.IsHandleCreated) {
//				return (Return) subject.Invoke (new Func<Subject, Func<Subject, Return>, Return> (SynchronizedGet<Subject, Return>),
//				                                 new object [] { subject, verb });
				return (Return) subject.Invoke (verb, subject);
			} else {
				return verb (subject);
				
				
				if (oldValue != 1) {
					Console.WriteLine ("GET unlocing thread");
					Interlocked.Exchange (ref Counter, 0);
					
					lock (lockObject) {
						Monitor.Pulse (lockObject);
					}
					
					lock (Helper.DelegateQueue.Lock) {
						Monitor.Pulse (Helper.DelegateQueue.Lock);
					}
				}
				
				Return v = verb (subject);

				return v;
			}
		}

		internal static int Counter = 0;
		static object lockObject = new object ();
//		static object lockObjectMonitor = new object ()

		internal static void SynchronizedSet (SWF.Control subject, Action<SWF.Control> verb)
		{
			lock (lockObject) {
				// If is being used, wait
				if (Interlocked.CompareExchange (ref Counter, 1, 1) == 1
				    && (InvokeThread != null && InvokeThread != Thread.CurrentThread))  {
					Console.WriteLine ("SET ya esta siendo usado...");
					Monitor.Wait (lockObject);
				}
			}
			
			if (subject.InvokeRequired && subject.IsHandleCreated) {
				subject.BeginInvoke (new Action<SWF.Control, Action<SWF.Control>> (SynchronizedSet), 
				                new object [] { subject, verb });
			} else {
				InvokeThread = Thread.CurrentThread;
				int oldValue = Interlocked.Exchange (ref Counter, 1);
				
				
				if (oldValue != 1) { // We are being called by Set/Get
					Console.WriteLine ("SET unlocing thread");
					Interlocked.Exchange (ref Counter, 0);
					
					lock (lockObject) {
						Monitor.Pulse (lockObject);
					}
					
					lock (Helper.DelegateQueue.Lock) {
						Monitor.Pulse (Helper.DelegateQueue.Lock);
					}
				
				}
	
				verb (subject);
				
			}
		}

		internal class DelegateQueue
		{
			public static DelegateQueue Get ()
			{
				if (consumer == null)
					consumer = new DelegateQueue ();
				
				return consumer;
			}

			public void Enqueue (QueueDelegate value)
			{
				lock (lockObj) {
					queue.Enqueue (value);
				}
			}
			
			public int Count {
				get {
					lock (lockObj) {
						return queue.Count;
					}
				}
			}

			public QueueDelegate Dequeue ()
			{
				lock (lockObj) {
					if (queue.Count == 0)
						return null;
					else
						return queue.Dequeue ();
				}
			}
			
			private DelegateQueue ()
			{
				queue = new System.Collections.Generic.Queue<QueueDelegate> ();
				threadConsumer = new Thread (new ThreadStart (Consume));
				threadConsumer.Name = "AIPConsumer";
				threadConsumer.Start ();
			}
			
			public void Quit ()
			{
				lock (lockObj) {
					Console.WriteLine ("Not proceseed events: {0}", queue.Count);
					close = true;
					lock (DelegateQueue.Lock) {
						Monitor.Pulse (DelegateQueue.Lock);
					}
				}
			}

			private void Consume ()
			{
				while (!close) {
					QueueDelegate action = Dequeue ();
					if (action == null || Interlocked.CompareExchange (ref Helper.Counter, 0, 0) != 0) {
						lock (DelegateQueue.Lock) {
							Console.WriteLine ("waiting...: {0}", action == null);
							Monitor.Wait (DelegateQueue.Lock);
							if (close)
								break;
							continue;
						}
					}
					Console.WriteLine ("Raising action!");
					action ();
				}
			}
			
			private bool close = false;

			public delegate void QueueDelegate ();

			public static readonly object Lock = new object (); 

			private object lockObj = new object ();
			private static DelegateQueue consumer;
			
			private Thread threadConsumer;
			private System.Collections.Generic.Queue<QueueDelegate> queue;
		}
		
		#endregion
		


		#endregion
	}

	internal static class InvokeRequiredExtensionControl
	{	
		public static TResult InvokeSync<TControl, TResult> (this TControl control,
		                                                       Func<TControl, TResult> func)
			where TControl : SWF.Control
		{
			// This happens when a Winforms event raises an AutomationEvent
			// that raises an Atk event that needs to request Winforms data :-)
			if (AlreadyInvoked)
				return (TResult) func (control);
			
			if (control.InvokeRequired && control.IsHandleCreated) {
				if (Interlocked.CompareExchange (ref alreadyInvoked, 1, 0) == 1) {
					TResult result = (TResult) control.Invoke (func, control);
					Interlocked.CompareExchange (ref alreadyInvoked, 0, 1);
					return result;
				} else
					return (TResult) func (control);
			} else
				return (TResult) func (control);
		}
		
		public static void InvokeSync<TControl> (this TControl control, 
		                                            Action<TControl> action)
			where TControl : SWF.Control
		{
			// We don't care about AlreadyInvoked since we are not 
			// returning a value.
			if (control.InvokeRequired && control.IsHandleCreated)
				control.BeginInvoke (action, control);
			else
				action (control);
		}

		private static bool AlreadyInvoked {
			get { return Interlocked.CompareExchange (ref alreadyInvoked, 0, 0) == 1; }
		}
		
		private static int alreadyInvoked = 0;
	}
}





		protected override ScrollBar HorizontalScrollBar { 
			get { 
				return listboxControl.InvokeSync (c => c.UIAHScrollBar); 
				                                                   s => listboxControl.UIAHScrollBar); 
			}
		}

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


			else if (propertyId == AutomationElementIdentifiers.LocalizedControlTypeProperty.Id)
				return Catalog.GetString ("list");
			else if (propertyId == AutomationElementIdentifiers.NameProperty.Id) {
				return listboxControl.InvokeSync (c => {
					if (string.IsNullOrEmpty (c.AccessibleName))
						return Helper.StripAmpersands (c.Text);
					else
						return c.AccessibleName;
				});
			} else
				return base.GetProviderPropertyValue (propertyId);

		
		public override IRawElementProviderFragment GetFocus ()
		{
			return listboxControl.InvokeSync (c => GetItemProviderFrom (this, c.Items [c.FocusedItem]));
			                                                                     c => GetItemProviderFrom (this, listboxControl.Items [listboxControl.FocusedItem]));
		}
		
		public override void FocusItem (object objectItem)
		{
			listboxControl.InvokeSync (delegate {
				listboxControl.FocusedItem = listboxControl.Items.IndexOf (objectItem);
			});
		}

		{
			base.InitializeChildControlStructure ();

			listboxControl.InvokeSync (delegate {
				listboxControl.Items.UIACollectionChanged += OnCollectionChanged;
				
				foreach (object objectItem in listboxControl.Items) {

		{
			base.FinalizeChildControlStructure ();

			listboxControl.InvokeSync (delegate {
				listboxControl.Items.UIACollectionChanged -= OnCollectionChanged;
			});
		}

		                                             int propertyId)
		{
			if (propertyId == AutomationElementIdentifiers.NameProperty.Id)
				return listboxControl.InvokeSync (s => s.GetItemText (item.ObjectItem));
				                                                s => listboxControl.GetItemText (item.ObjectItem));
			
			if (ContainsItem (item) == false)
				return null;

			if (propertyId == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)
				return listboxControl.InvokeSync (s => s.Focused 
				                                  && item.Index == s.FocusedItem);
				                                              && item.Index == listboxControl.FocusedItem);
			else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {
				return listboxControl.InvokeSync (c => {
					System.Drawing.Rectangle itemRec = System.Drawing.Rectangle.Empty;
					System.Drawing.Rectangle rectangle = c.Bounds;
	
					itemRec = c.GetItemRectangle (item.Index);
					itemRec.X += rectangle.X;
					itemRec.Y += rectangle.Y;
					
					if (c.FindForm () == c.Parent)
						itemRec = c.TopLevelControl.RectangleToScreen (itemRec);
					else
						itemRec = c.Parent.RectangleToScreen (itemRec);
		
					return Helper.RectangleToRect (itemRec);
				});

		#region ListProvider: Specializations
		
		public override int SelectedItemsCount {
			get { return listboxControl.InvokeSync (c => c.SelectedItems.Count); }
		}
		
		public override int ItemsCount {
			get { return listboxControl.InvokeSync (c => c.Items.Count); }
		}

		public override int IndexOfObjectItem (object objectItem)
		{
			return listboxControl.InvokeSync (c => c.Items.IndexOf (objectItem));
		}
		
		public override IRawElementProviderSimple[] GetSelectedItems ()

			ListItemProvider []items;

			if (listboxControl == null 
			    || listboxControl.InvokeSync (c => c.SelectedIndices.Count == 0))
			                                              c => listboxControl.SelectedIndices.Count == 0))
				return new ListItemProvider [0];

			return listboxControl.InvokeSync (c => {
				items = new ListItemProvider [c.SelectedIndices.Count];		
				for (int index = 0; index < items.Length; index++) 
					items [index] = GetItemProviderFrom (this, c.Items [c.SelectedIndices [index]]);
				
				return items;
			});

		
		public override void SelectItem (ListItemProvider item)
		{
			listboxControl.InvokeSync (delegate {
				listboxControl.SetSelected (item.Index, true);
			});
		}

		public override void UnselectItem (ListItemProvider item)
		{
			listboxControl.InvokeSync (delegate {
				listboxControl.SetSelected (item.Index, false);
			});
		}
		
		public override bool IsItemSelected (ListItemProvider item)
		{
			return listboxControl.InvokeSync (b => b.SelectedIndices.Contains (item.Index));
			                                              b => listboxControl.SelectedIndices.Contains (item.Index));
		}

		public override IConnectable GetListItemEventRealization (ProviderEventType eventType, 

		public override void ScrollItemIntoView (ListItemProvider item)
		{
			if (ContainsItem (item) == true)
				listboxControl.InvokeSync (delegate {
					listboxControl.TopIndex = item.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: 
//	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))
				                                                    v => listView.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))
				                                                    v => listView.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))
				    || Helper.SynchronizedGet<SWF.ListView, bool> (listView,
				                                                vi => listView.View == SWF.View.List)
				    || Helper.SynchronizedGet<SWF.ListView, bool> (listView,
				                                                d => listView.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))
				                                                v => listView.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)
				                                                v => listView.View != SWF.View.Details)
				    || IsBehaviorEnabled (GridPatternIdentifiers.Pattern))
					return new ListItemGridItemProviderBehavior (listItem);
				else
					return null;
			} else if (behavior == ValuePatternIdentifiers.Pattern) {
				if (listView.InvokeSync (c => c.LabelEdit))
				                                                e => listView.LabelEdit))
					return new ListItemValueProviderBehavior (listItem);
				else
					return null;
			} else if (behavior == TogglePatternIdentifiers.Pattern) {
				if (listView.InvokeSync (c => c.CheckBoxes))
				                                                e => listView.CheckBoxes))
					return new ListItemToggleProviderBehavior (listItem);
				else
					return null;
			} else if (behavior == TableItemPatternIdentifiers.Pattern) {
				if (listView.InvokeSync (c => c.View == SWF.View.Details))
				                                                d => listView.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);
					&& ((SWF.ListViewItem)item.ObjectItem).Focused;
			else if (propertyId == AutomationElementIdentifiers.BoundingRectangleProperty.Id) {
				int index = item.Index;

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

				SD.Rectangle itemRec 
					= listView.InvokeSync (c => c.GetItemRect (index));
					                                                      i => listView.GetItemRect (index));
				SD.Rectangle rectangle 
					= listView.InvokeSync (c => c.Bounds);
					                                                      i => listView.Bounds);
				
				itemRec.X += rectangle.X;
				itemRec.Y += rectangle.Y;
				
				itemRec = listView.InvokeSync (c => c.Parent.RectangleToScreen (itemRec));
					                                                      i => listView.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),
				                                                                                       i => listView.UIAHeaderControl),
				                                   ScrollBehaviorObserver);
			else if (propertyId == AutomationElementIdentifiers.IsKeyboardFocusableProperty.Id)
				return true;

		{
			base.InitializeChildControlStructure ();

			listView.Items.UIACollectionChanged += OnCollectionChanged;
				listView.Items.UIACollectionChanged += OnCollectionChanged;
			});

			// Use to regenerate children when view changes
			listView.UIAViewChanged += OnUIAViewChanged;

		{
			base.FinalizeChildControlStructure ();

			listView.Items.UIACollectionChanged -= OnCollectionChanged;
				listView.Items.UIACollectionChanged -= OnCollectionChanged;
			});

			listView.UIAViewChanged -= OnUIAViewChanged;
		}
		
		public override int ItemsCount { 
			get { return listView.InvokeSync (c => c.Items.Count); }
				return Helper.SynchronizedGet<SWF.ListView, int> (listView,
				                                                  c => listView.Items.Count);
			}
		}

		public override int IndexOfObjectItem (object objectItem)
		{
			return listView.InvokeSync (c => c.Items.IndexOf (objectItem as SWF.ListViewItem));
			                                                  c => listView.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); }
				return Helper.SynchronizedGet<SWF.ListView, int> (listView,
				                                                  c => listView.SelectedItems.Count);
			}
		}
		
		public override bool IsItemSelected (ListItemProvider item)
		{
			return listView.InvokeSync (c => c.SelectedIndices.Contains (item.Index));
			                                                   c => listView.SelectedIndices.Contains (item.Index));
		}
		
		public override IRawElementProviderSimple[] GetSelectedItems ()
		{
			if (listView == null)
				return new ListItemProvider [0];
			
			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;
				});
		}

		
		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)
				                                                   c => listView.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; 
				});
		}
		

			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

		#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;
		}


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

				SWF.ListViewItem listViewItem = (SWF.ListViewItem) 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)) {
			                                                && listView.View != SWF.View.List)) {
				UpdateChildrenStructure (true);
				if (SWF.Application.VisualStylesEnabled == true)
					SetBehavior (GridPatternIdentifiers.Pattern,


			private Rect HeaderRectangle {
				get {
					return listView.InvokeSync (c => {	
					                                                   delegate {
				
						// 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);
						
					});
				}
			}

			{
				base.InitializeChildControlStructure ();
				
				listView.InvokeSync (delegate {
					//Event used to update columns in ListItem when View.Details
					listView.Columns.UIACollectionChanged += OnUIAColumnsCollectionChanged;
	

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

				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;
					});					

			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)) {
				                                                                                       c => listView.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))
				                                                       c => listView.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))
				                                                c => listView.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);
					                                                                    b => itemProvider.ListView.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))
					                                                || ItemProvider.ListView.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;
					});

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/MenuStripProvider.cs (-2 / +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 (Helper.SynchronizedGet<MenuStrip, Orientation> (menu,	57	switch (menu.InvokeSync (o => menu.Orientation)) {
58	o => menu.Orientation)) {
59	case Orientation.Vertical:	58	case Orientation.Vertical:
60	return OrientationType.Vertical;	59	return OrientationType.Vertical;
61	case Orientation.Horizontal:	60	case Orientation.Horizontal:

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	}




		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		214
215	return Helper.RectToRectangle (	215	return Control.InvokeSync (c => {
216	Helper.GetControlScreenBounds (Control.Bounds, Control)	216	if (!c.Visible)
217	);	217	return System.Drawing.Rectangle.Empty;
		218
		219	return Helper.RectToRectangle (Helper.GetControlScreenBounds (c.Bounds, c));
		220	});
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 (-3 / +6 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




		
		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>

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

#endregion

		internal bool HasSelection {
			get { return control.InvokeSync (c => c.SelectedIndex > -1); }
				return Helper.SynchronizedGet<TabControl, bool> (
					control, c => c.SelectedIndex > -1
				);
			}
		}

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

			if (page == null)
				return null;


		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);
				control, 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>

				// 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 => Helper.RectangleToRect (
						v.Parent.RectangleToScreen (tabPage.TabBounds)));
			}


			// 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 {




		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;
				});
			}
		}


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-63 namespace Mono.UIAutomation.Winforms Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/ToolStripButtonProvider.cs (-3 / +1 lines)
55		55
56	protected override object GetProviderPropertyValue (int propertyId)	56	protected override object GetProviderPropertyValue (int propertyId)
57	{	57	{
58	bool checkOnClick = Helper.SynchronizedGet<ToolStrip, bool> (	58	bool checkOnClick = Owner.InvokeSync (t => button.CheckOnClick);
59	Owner, t => button.CheckOnClick
60	);
61		59
62	if (propertyId == AEIds.ControlTypeProperty.Id)	60	if (propertyId == AEIds.ControlTypeProperty.Id)
63	return checkOnClick ? ControlType.CheckBox.Id : ControlType.Button.Id;	61	return checkOnClick ? ControlType.CheckBox.Id : ControlType.Button.Id;

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 59-65 namespace Mono.UIAutomation.Winforms Link Here

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




			if (AutomationInteropProvider.ClientsAreListening == true) {					
				message = GetTextFromControl (control);

//				Helper.DelegateQueue.Get ().Enqueue (delegate {
				
				//TODO: We need deeper tests in Vista because MS is generating both events
				Helper.RaiseStructureChangedEvent (StructureChangeType.ChildAdded,

				                                                this, 
				                                                eventArgs);

//				});
			}
		}
		

			if (AutomationInteropProvider.ClientsAreListening == true) {
				message = GetTextFromControl (control);

//				Helper.DelegateQueue.Get ().Enqueue (delegate {
				
				//TODO: We need deeper tests in Vista because MS is generating both events
				Helper.RaiseStructureChangedEvent (StructureChangeType.ChildRemoved,

				AutomationInteropProvider.RaiseAutomationEvent (AutomationElementIdentifiers.ToolTipClosedEvent,
				                                                this, 
				                                                eventArgs);
//				});
			}
		}


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 66-71 FILES = \ Link Here

(-)a/UIAutomationWinforms/UIAutomationWinformsTests/Makefile.am (+1 lines)
66	DateTimePickerProviderTest.cs \	66	DateTimePickerProviderTest.cs \
67	DomainUpDownProviderTest.cs \	67	DomainUpDownProviderTest.cs \
68	ErrorProviderTest.cs \	68	ErrorProviderTest.cs \
		69	FormProviderTest.cs \
69	GroupBoxProviderTest.cs \	70	GroupBoxProviderTest.cs \
70	HelpProviderTest.cs \	71	HelpProviderTest.cs \
71	LabelProviderTest.cs \	72	LabelProviderTest.cs \

Lines 66-72 Link Here

(-)a/UIAutomationWinforms/UIAutomationWinformsTests/UIAutomationWinformsTests.mdp (-1 / +1 lines)
66	<File name="DateTimePickerProviderTest.cs" subtype="Code" buildaction="Compile" />	66	<File name="DateTimePickerProviderTest.cs" subtype="Code" buildaction="Compile" />
67	<File name="ToolStripButtonProviderTest.cs" subtype="Code" buildaction="Compile" />	67	<File name="ToolStripButtonProviderTest.cs" subtype="Code" buildaction="Compile" />
68	<File name="PopupButtonPanelTest.cs" subtype="Code" buildaction="Compile" />	68	<File name="PopupButtonPanelTest.cs" subtype="Code" buildaction="Compile" />
69	<File name="FormProviderTest.cs" subtype="Code" buildaction="Nothing" />	69	<File name="FormProviderTest.cs" subtype="Code" buildaction="Compile" />
70	<File name="MainMenuProviderTest.cs" subtype="Code" buildaction="Compile" />	70	<File name="MainMenuProviderTest.cs" subtype="Code" buildaction="Compile" />
71	<File name="MenuItemProviderTest.cs" subtype="Code" buildaction="Compile" />	71	<File name="MenuItemProviderTest.cs" subtype="Code" buildaction="Compile" />
72	<File name="DataGridProviderTest.cs" subtype="Code" buildaction="Compile" />	72	<File name="DataGridProviderTest.cs" subtype="Code" buildaction="Compile" />

Return to bug 494034

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

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

Lines 90-101 namespace Mono.UIAutomation.Winforms.Behaviors.Button Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/Button/InvokeProviderBehavior.cs (-4 / +2 lines)
90		90
91	public virtual void Invoke ()	91	public virtual void Invoke ()
92	{	92	{
93	if (Helper.SynchronizedGet<SWF.Button, bool> (button, b => !b.Enabled))	93	if (button.InvokeSync (c => !c.Enabled))
94	throw new ElementNotEnabledException ();	94	throw new ElementNotEnabledException ();
95		95
96	Helper.SynchronizedSet (button, delegate {	96	button.InvokeSync (delegate { button.PerformClick (); });
97	button.PerformClick ();
98	});
99	}	97	}
100		98
101	#endregion	99	#endregion

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

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

Lines 80-87 namespace Mono.UIAutomation.Winforms.Behaviors.ComboBox Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ComboBox/ExpandCollapseProviderBehavior.cs (-8 / +5 lines)
80	public ExpandCollapseState ExpandCollapseState {	80	public ExpandCollapseState ExpandCollapseState {
81	get {	81	get {
82	SWF.ComboBox combobox = (SWF.ComboBox) Provider.Control;	82	SWF.ComboBox combobox = (SWF.ComboBox) Provider.Control;
83	if (Helper.SynchronizedGet<SWF.ComboBox, bool> (combobox,	83	if (combobox.InvokeSync (c => c.DroppedDown))
84	c => c.DroppedDown))
85	return ExpandCollapseState.Expanded;	84	return ExpandCollapseState.Expanded;
86	else	85	else
87	return ExpandCollapseState.Collapsed;	86	return ExpandCollapseState.Collapsed;
Lines 92-102 namespace Mono.UIAutomation.Winforms.Behaviors.ComboBox Link Here
92	{	91	{
93	SWF.ComboBox combobox = (SWF.ComboBox) Provider.Control;	92	SWF.ComboBox combobox = (SWF.ComboBox) Provider.Control;
94		93
95	if (Helper.SynchronizedGet<SWF.ComboBox, bool> (combobox,	94	if (combobox.InvokeSync (c => !c.Enabled))
96	c => !c.Enabled))
97	throw new ElementNotEnabledException ();	95	throw new ElementNotEnabledException ();
98		96
99	Helper.SynchronizedSet (combobox, delegate {	97	combobox.InvokeSync (delegate {
100	combobox.DroppedDown = false;	98	combobox.DroppedDown = false;
101	});	99	});
102	}	100	}
Lines 105-115 namespace Mono.UIAutomation.Winforms.Behaviors.ComboBox Link Here
105	{	103	{
106	SWF.ComboBox combobox = (SWF.ComboBox) Provider.Control;	104	SWF.ComboBox combobox = (SWF.ComboBox) Provider.Control;
107		105
108	if (Helper.SynchronizedGet<SWF.ComboBox, bool> (combobox,	106	if (combobox.InvokeSync (c => !c.Enabled))
109	c => !c.Enabled))
110	throw new ElementNotEnabledException ();	107	throw new ElementNotEnabledException ();
111		108
112	Helper.SynchronizedSet (combobox, delegate {	109	combobox.InvokeSync (delegate {
113	combobox.DroppedDown = true;	110	combobox.DroppedDown = true;
114	});	111	});
115	}	112	}

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ComboBox/ValueProviderBehavior.cs (-3 / +3 lines)
83	#region IValueProvider Interface	83	#region IValueProvider Interface
84		84
85	public bool IsReadOnly {	85	public bool IsReadOnly {
86	get { return Helper.SynchronizedGet<Control, bool> (Provider.Control, c => !c.Enabled); }	86	get { return Provider.Control.InvokeSync (c => !c.Enabled); }
87	}	87	}
88		88
89	public string Value {	89	public string Value {
90	get { return Helper.SynchronizedGet<Control, string> (Provider.Control, c => c.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-101 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	Helper.SynchronizedSet (Provider.Control, delegate {	98	Provider.Control.InvokeSync (delegate {
99	Provider.Control.Text = value;	99	Provider.Control.Text = value;
100	});	100	});
101	}	101	}

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/Form/TransformProviderBehavior.cs (-9 / +4 lines)
91		91
92	public bool CanMove {	92	public bool CanMove {
93	get {	93	get {
94	//return Helper.SynchronizedGet<SWF.Form, bool> (form,	94	return form.InvokeSync (f => f.WindowState == SWF.FormWindowState.Normal);
95	return Helper.SynchronizedGet<SWF.Form, bool> ((SWF.Form) Provider.Control,
96	f => f.WindowState == SWF.FormWindowState.Normal);
97	}	95	}
98	}	96	}
99		97
100	public bool CanResize {	98	public bool CanResize {
101	get {	99	get {
102	//switch (Helper.SynchronizedGet<SWF.Form, SWF.FormBorderStyle> (form,	100	switch (form.InvokeSync (f => f.FormBorderStyle)) {
103	//switch (Helper.SynchronizedGet<SWF.Form, SWF.FormBorderStyle> ((SWF.Form) Provider.Control,
104	// v => v.FormBorderStyle)) {
105	switch (form.FormBorderStyle) {
106	case SWF.FormBorderStyle.Fixed3D:	101	case SWF.FormBorderStyle.Fixed3D:
107	case SWF.FormBorderStyle.FixedDialog:	102	case SWF.FormBorderStyle.FixedDialog:
108	case SWF.FormBorderStyle.FixedSingle:	103	case SWF.FormBorderStyle.FixedSingle:
Lines 125-131 namespace Mono.UIAutomation.Winforms.Behaviors.Form Link Here
125	if (!CanMove)	120	if (!CanMove)
126	throw new InvalidOperationException ("CanMove is false");	121	throw new InvalidOperationException ("CanMove is false");
127		122
128	Helper.SynchronizedSet (form, delegate {	123	form.InvokeSync (delegate {
129	form.Location = new Point ((int) x, (int) y);	124	form.Location = new Point ((int) x, (int) y);
130	});	125	});
131	}	126	}
Lines 137-143 namespace Mono.UIAutomation.Winforms.Behaviors.Form Link Here
137	if (!CanResize)	132	if (!CanResize)
138	throw new InvalidOperationException ("CanResize is false");	133	throw new InvalidOperationException ("CanResize is false");
139		134
140	Helper.SynchronizedSet (form, delegate {	135	form.InvokeSync (delegate {
141	form.Size = new Size ((int) width, (int) height);	136	form.Size = new Size ((int) width, (int) height);
142	});	137	});
143	}	138	}

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/Form/WindowProviderBehavior.cs (-30 / +8 lines)
141		141
142	public void SetVisualState (WindowVisualState state)	142	public void SetVisualState (WindowVisualState state)
143	{	143	{
144	SWF.FormWindowState newState = Helper.SynchronizedGet<SWF.Form, SWF.FormWindowState> (form,	144	SWF.FormWindowState newState = form.InvokeSync (f => f.WindowState);
145	f => f.WindowState);
146	switch (state) {	145	switch (state) {
147	case WindowVisualState.Maximized:	146	case WindowVisualState.Maximized:
148	newState = SWF.FormWindowState.Maximized;	147	newState = SWF.FormWindowState.Maximized;
Lines 155-202 namespace Mono.UIAutomation.Winforms.Behaviors.Form Link Here
155	break;	154	break;
156	}	155	}
157		156
158	Helper.SynchronizedSet (form, delegate {	157	form.InvokeSync (delegate { form.WindowState = newState; });
159	form.WindowState = newState;
160	});
161	}	158	}
162		159
163	public void Close ()	160	public void Close ()
164	{	161	{
165	Helper.SynchronizedSet (form, delegate {	162	form.InvokeSync (delegate { form.Close (); });
166	form.Close ();
167	});
168	}	163	}
169		164
170	public bool Minimizable {	165	public bool Minimizable {
171	get {	166	get { return form.InvokeSync (f => f.MinimizeBox); }
172	//return Helper.SynchronizedGet<SWF.Form, bool> (form,
173	return Helper.SynchronizedGet<SWF.Form, bool> ((SWF.Form) Provider.Control,
174	f => f.MinimizeBox);
175	}
176	}	167	}
177		168
178	public bool Maximizable {	169	public bool Maximizable {
179	get {	170	get { return form.InvokeSync (f => f.MaximizeBox); }
180	//return Helper.SynchronizedGet<SWF.Form, bool> (form,
181	return Helper.SynchronizedGet<SWF.Form, bool> ((SWF.Form) Provider.Control,
182	f => f.MaximizeBox);
183	}
184	}	171	}
185		172
186	public bool IsTopmost {	173	public bool IsTopmost {
187	get {	174	get { return form.InvokeSync (f => f.TopMost); }
188	//return Helper.SynchronizedGet<SWF.Form, bool> (form,
189	return Helper.SynchronizedGet<SWF.Form, bool> ((SWF.Form) Provider.Control,
190	f => f.TopMost);
191	}
192	}	175	}
193		176
194	public bool IsModal {	177	public bool IsModal {
195	get {	178	get { return form.InvokeSync (f => f.Modal); }
196	return Helper.SynchronizedGet<SWF.Form, bool> ((SWF.Form) Provider.Control,
197	// return Helper.SynchronizedGet<SWF.Form, bool> (form,
198	f => f.Modal);
199	}
200	}	179	}
201		180
202	public WindowInteractionState InteractionState {	181	public WindowInteractionState InteractionState {
Lines 211-218 namespace Mono.UIAutomation.Winforms.Behaviors.Form Link Here
211		190
212	public WindowVisualState VisualState {	191	public WindowVisualState VisualState {
213	get {	192	get {
214	switch (Helper.SynchronizedGet<SWF.Form, SWF.FormWindowState> (form,	193	switch (form.InvokeSync (f => f.WindowState)) {
215	f => f.WindowState)) {
216	case SWF.FormWindowState.Maximized:	194	case SWF.FormWindowState.Maximized:
217	return WindowVisualState.Maximized;	195	return WindowVisualState.Maximized;
218	case SWF.FormWindowState.Minimized:	196	case SWF.FormWindowState.Minimized:

Lines 105-116 namespace Mono.UIAutomation.Winforms.Behaviors.Generic Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/Generic/ScrollProviderBehavior.cs (-36 / +19 lines)
105	if (HorizontallyScrollable == false)	105	if (HorizontallyScrollable == false)
106	return ScrollPatternIdentifiers.NoScroll;	106	return ScrollPatternIdentifiers.NoScroll;
107	else {	107	else {
108	return Helper.SynchronizedGet<SWF.ScrollBar, double> (hscrollbar,	108	return hscrollbar.InvokeSync (c => {
109	delegate {	109	if (c.Maximum == 0)
110	if (hscrollbar.Maximum == 0)
111	return ScrollPatternIdentifiers.NoScroll;	110	return ScrollPatternIdentifiers.NoScroll;
112	else	111	else
113	return (hscrollbar.Value * 100) / hscrollbar.Maximum;	112	return (double) ((c.Value * 100) / c.Maximum);
114	});	113	});
115	}	114	}
116	}	115	}
Lines 138-149 namespace Mono.UIAutomation.Winforms.Behaviors.Generic Link Here
138	if (VerticallyScrollable == false)	137	if (VerticallyScrollable == false)
139	return ScrollPatternIdentifiers.NoScroll;	138	return ScrollPatternIdentifiers.NoScroll;
140	else {	139	else {
141	return Helper.SynchronizedGet<SWF.ScrollBar, double> (vscrollbar,	140	return vscrollbar.InvokeSync (c => {
142	delegate {	141	if (c.Maximum == 0)
143	if (vscrollbar.Maximum == 0)
144	return ScrollPatternIdentifiers.NoScroll;	142	return ScrollPatternIdentifiers.NoScroll;
145	else	143	else
146	return (vscrollbar.Value * 100) / vscrollbar.Maximum;	144	return (double) ((c.Value * 100) / c.Maximum);
147	});	145	});
148	}	146	}
149	}	147	}
Lines 179-187 namespace Mono.UIAutomation.Winforms.Behaviors.Generic Link Here
179	if (horizontalPercent < 0 \|\| horizontalPercent > 100)	177	if (horizontalPercent < 0 \|\| horizontalPercent > 100)
180	throw new ArgumentOutOfRangeException ();	178	throw new ArgumentOutOfRangeException ();
181	else {	179	else {
182	double maximum = Helper.SynchronizedGet<SWF.ScrollBar, double> (hscrollbar,	180	double maximum = hscrollbar.InvokeSync (h => h.Maximum);
183	h => h.Maximum);	181	hscrollbar.InvokeSync (delegate {
184	PerformScrollByPercent (hscrollbar, (int) ((horizontalPercent * maximum) / 100));	182	hscrollbar.Value = (int) ((horizontalPercent * maximum) / 100);
		183	});
185	}	184	}
186	}	185	}
187		186
Lines 189-197 namespace Mono.UIAutomation.Winforms.Behaviors.Generic Link Here
189	if (verticalPercent < 0 \|\| verticalPercent > 100)	188	if (verticalPercent < 0 \|\| verticalPercent > 100)
190	throw new ArgumentOutOfRangeException ();	189	throw new ArgumentOutOfRangeException ();
191	else {	190	else {
192	double maximum = Helper.SynchronizedGet<SWF.ScrollBar, double> (vscrollbar,	191	double maximum = vscrollbar.InvokeSync (v => v.Maximum);
193	v => v.Maximum);	192	hscrollbar.InvokeSync (delegate {
194	PerformScrollByPercent (vscrollbar, (int) ((verticalPercent * maximum) / 100));	193	vscrollbar.Value = (int) ((verticalPercent * maximum) / 100);
		194	});
195	}	195	}
196	}	196	}
197	}	197	}
Lines 242-269 namespace Mono.UIAutomation.Winforms.Behaviors.Generic Link Here
242	invoke	242	invoke
243	= (Action<SWF.ScrollBar>) Delegate.CreateDelegate (typeof (Action<SWF.ScrollBar>),	243	= (Action<SWF.ScrollBar>) Delegate.CreateDelegate (typeof (Action<SWF.ScrollBar>),
244	methodInfo);	244	methodInfo);
245	PerformScrollByAmount (scrollbar);	245
246	}	246	scrollbar.InvokeSync (delegate {
247		247	invoke (scrollbar);
248	private void PerformScrollByAmount (SWF.ScrollBar scrollbar)	248	invoke = null;
249	{	249	});
250	if (scrollbar.InvokeRequired == true) {
251	scrollbar.BeginInvoke (new ScrollByAmountDelegate (PerformScrollByAmount),
252	new object [] { scrollbar });
253	return;
254	}
255	invoke (scrollbar);
256	invoke = null;
257	}
258
259	private void PerformScrollByPercent (SWF.ScrollBar scrollbar, int value)
260	{
261	if (scrollbar.InvokeRequired == true) {
262	scrollbar.BeginInvoke (new ScrollByPercentDelegate (PerformScrollByPercent),
263	new object [] { scrollbar, value });
264	return;
265	}
266	scrollbar.Value = value;
267	}	250	}
268		251
269	#endregion	252	#endregion

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

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

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListView/ListItemEditGridItemProviderBehavior.cs (-8 / +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 Helper.SynchronizedGet<SWF.ListView, int> (listView,	109	return listView.InvokeSync (c => c.Items.IndexOf (editProvider.ItemProvider.ListViewItem) );
110	delegate {
111	return listView.Items.IndexOf (editProvider.ItemProvider.ListViewItem);
112	});
113	}	110	}
114	}	111	}
115		112
116	public int Column {	113	public int Column {
117	get {	114	get {
118	SWF.ListView listView = editProvider.ItemProvider.ListView;	115	SWF.ListView listView = editProvider.ItemProvider.ListView;
119	return Helper.SynchronizedGet<SWF.ListView, int> (listView,	116	return listView.InvokeSync (c => c.Columns.IndexOf (editProvider.ColumnHeader) );
120	delegate {
121	return listView.Columns.IndexOf (editProvider.ColumnHeader);
122	});
123	}	117	}
124	}	118	}
125		119

Lines 68-82 namespace Mono.UIAutomation.Winforms.Behaviors.ListView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ListView/ListItemEmbeddedImageProviderBehavior.cs (-4 / +4 lines)
68	if (item == null \|\| item.ListView == null)	68	if (item == null \|\| item.ListView == null)
69	return System.Windows.Rect.Empty;	69	return System.Windows.Rect.Empty;
70		70
71	return Helper.SynchronizedGet<SWF.ListView, System.Windows.Rect> (item.ListView, delegate {	71	return item.ListView.InvokeSync (c => {
72	if (item.ImageIndex == -1 && item.ImageKey == string.Empty)	72	if (item.ImageIndex == -1 && item.ImageKey == string.Empty)
73	return System.Windows.Rect.Empty;	73	return System.Windows.Rect.Empty;
74		74
75	SWF.ImageList imageList = null;	75	SWF.ImageList imageList = null;
76	if (item.ListView.View == SWF.View.LargeIcon)	76	if (c.View == SWF.View.LargeIcon)
77	imageList = item.ListView.LargeImageList;	77	imageList = c.LargeImageList;
78	else	78	else
79	imageList = item.ListView.SmallImageList;	79	imageList = c.SmallImageList;
80		80
81	if (imageList == null)	81	if (imageList == null)
82	return System.Windows.Rect.Empty;	82	return System.Windows.Rect.Empty;

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/MaskedTextBox/InsertDeleteTextProviderBehavior.cs (-6 / +4 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 (Helper.SynchronizedGet<SWF.MaskedTextBox, bool> (maskedTextBox,	67	if (maskedTextBox.InvokeSync (m => m.ReadOnly))
68	m => m.ReadOnly))
69	throw new ElementNotEnabledException ();	68	throw new ElementNotEnabledException ();
70		69
71	int newPosition = position;	70	int newPosition = position;
72		71
73	Helper.SynchronizedSet (maskedTextBox, delegate {	72	maskedTextBox.InvokeSync (delegate {
74		73
75	System.ComponentModel.MaskedTextProvider prov	74	System.ComponentModel.MaskedTextProvider prov
76	= maskedTextBox.MaskedTextProvider;	75	= maskedTextBox.MaskedTextProvider;
Lines 130-140 namespace Mono.UIAutomation.Winforms.Behaviors.MaskedTextBox Link Here
130		129
131	public void DeleteText (int start, int end)	130	public void DeleteText (int start, int end)
132	{	131	{
133	if (Helper.SynchronizedGet<SWF.MaskedTextBox, bool> (maskedTextBox,	132	if (maskedTextBox.InvokeSync (m => m.ReadOnly))
134	m => m.ReadOnly))
135	throw new ElementNotEnabledException ();	133	throw new ElementNotEnabledException ();
136		134
137	Helper.SynchronizedSet (maskedTextBox, delegate {	135	maskedTextBox.InvokeSync (delegate {
138	// MaskedTextProvider.RemoveAt does not work for this.	136	// MaskedTextProvider.RemoveAt does not work for this.
139	System.ComponentModel.MaskedTextProvider prov	137	System.ComponentModel.MaskedTextProvider prov
140	= maskedTextBox.MaskedTextProvider;	138	= maskedTextBox.MaskedTextProvider;

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/NumericUpDown/EditableRangeProviderBehavior.cs (-4 / +3 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 (Helper.SynchronizedGet<SWF.NumericUpDown, bool> (numericUpDown,	68	if (numericUpDown.InvokeSync (n => numericUpDown.ReadOnly))
69	n => numericUpDown.ReadOnly))
70	throw new ElementNotEnabledException ();	69	throw new ElementNotEnabledException ();
71		70
72	Helper.SynchronizedSet (numericUpDown, delegate {	71	numericUpDown.InvokeSync (delegate {
73	numericUpDown.txtView.Text = text;	72	numericUpDown.txtView.Text = text;
74	});	73	});
75	}	74	}
76		75
77	public void CommitEdit ()	76	public void CommitEdit ()
78	{	77	{
79	Helper.SynchronizedSet (numericUpDown, delegate {	78	numericUpDown.InvokeSync (delegate {
80	decimal value = decimal.Parse (numericUpDown.Text);	79	decimal value = decimal.Parse (numericUpDown.Text);
81	if (value < numericUpDown.Minimum)	80	if (value < numericUpDown.Minimum)
82	value = numericUpDown.Minimum;	81	value = numericUpDown.Minimum;

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/PictureBox/EmbeddedImageProviderBehavior.cs (-4 / +3 lines)
63	#region IEmbeddedImageProvider Interface	63	#region IEmbeddedImageProvider Interface
64	public Rect Bounds {	64	public Rect Bounds {
65	get {	65	get {
66	return Helper.SynchronizedGet<SWF.PictureBox, Rect> (control,	66	return control.InvokeSync (c => {
67	delegate {	67	if (c.Image == null)
68	if (control.Image == null)
69	return Rect.Empty;	68	return Rect.Empty;
70		69
71	GraphicsUnit unit = GraphicsUnit.Pixel;	70	GraphicsUnit unit = GraphicsUnit.Pixel;
72	RectangleF rectF = control.Image.GetBounds (ref unit);	71	RectangleF rectF = c.Image.GetBounds (ref unit);
73		72
74	if (unit != GraphicsUnit.Pixel)	73	if (unit != GraphicsUnit.Pixel)
75	return Rect.Empty;	74	return Rect.Empty;

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/SplitContainer/DockProviderBehavior.cs (-8 / +2 lines)
76	#region IDockProvider Members	76	#region IDockProvider Members
77		77
78	public DockPosition DockPosition {	78	public DockPosition DockPosition {
79	get {	79	get { return splitContainer.InvokeSync (s => Helper.GetDockPosition (s.Dock)); }
80	return Helper.SynchronizedGet<SWF.SplitContainer, DockPosition> (
81	splitContainer, s => Helper.GetDockPosition (s.Dock)
82	);
83	}
84	}	80	}
85		81
86	public void SetDockPosition (DockPosition dockPosition)	82	public void SetDockPosition (DockPosition dockPosition)
87	{	83	{
88	//throw new InvalidOperationException ();	84	//throw new InvalidOperationException ();
89		85
90	Helper.SynchronizedSet (splitContainer, delegate {	86	splitContainer.InvokeSync (delegate {
91	splitContainer.Dock = Helper.GetDockStyle (dockPosition);	87	splitContainer.Dock = Helper.GetDockStyle (dockPosition);
92	});	88	});
93	}	89	}
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 105-122 namespace Mono.UIAutomation.Winforms.Behaviors.TabControl Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/TabControl/ScrollProviderBehavior.cs (-8 / +4 lines)
105		105
106	public double HorizontalScrollPercent {	106	public double HorizontalScrollPercent {
107	get {	107	get {
108	return Helper.SynchronizedGet<SWF.TabControl, double> (tabControl, t => {	108	return tabControl.InvokeSync (t => {
109	if (!t.ShowSlider)	109	if (!t.ShowSlider)
110	return ScrollPatternIdentifiers.NoScroll;	110	return ScrollPatternIdentifiers.NoScroll;
111	else	111	else
112	return 100 / t.TabCount;	112	return (double) (100 / t.TabCount);
113	});	113	});
114	}	114	}
115	}	115	}
116		116
117	public double HorizontalViewSize {	117	public double HorizontalViewSize {
118	get {	118	get {
119	return Helper.SynchronizedGet<SWF.TabControl, double> (tabControl, t => {	119	return tabControl.InvokeSync (t => {
120	if (!t.ShowSlider)	120	if (!t.ShowSlider)
121	return 100;	121	return 100;
122	else {	122	else {
Lines 146-156 namespace Mono.UIAutomation.Winforms.Behaviors.TabControl Link Here
146	}	146	}
147		147
148	public bool HorizontallyScrollable {	148	public bool HorizontallyScrollable {
149	get {	149	get { return tabControl.InvokeSync (t => t.ShowSlider); }
150	return Helper.SynchronizedGet<SWF.TabControl, bool> (
151	tabControl, t => t.ShowSlider
152	);
153	}
154	}	150	}
155		151
156	public bool VerticallyScrollable {	152	public bool VerticallyScrollable {

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/TextBox/ClipboardProviderBehavior.cs (-6 / +9 lines)
62		62
63	public void Copy (int start, int end)	63	public void Copy (int start, int end)
64	{	64	{
65	Helper.SynchronizedSet (TextBoxBase, delegate {	65	TextBoxBase.InvokeSync (delegate {
66	string text = Text;	66	string text = Text;
67	start = (int) System.Math.Max (start, 0);	67	start = (int) System.Math.Max (start, 0);
68	end = (int) System.Math.Min (end, text.Length);	68	end = (int) System.Math.Min (end, text.Length);
Lines 72-78 namespace Mono.UIAutomation.Winforms.Behaviors.TextBox Link Here
72		72
73	public void Paste (int position)	73	public void Paste (int position)
74	{	74	{
75	Helper.SynchronizedSet (TextBoxBase, delegate {	75	TextBoxBase.InvokeSync (delegate {
76	string text = Text;	76	string text = Text;
77	position = (int) System.Math.Max (position, 0);	77	position = (int) System.Math.Max (position, 0);
78	position = (int) System.Math.Min (position, text.Length);	78	position = (int) System.Math.Min (position, text.Length);
Lines 105-111 namespace Mono.UIAutomation.Winforms.Behaviors.TextBox Link Here
105	if (Provider.Control is SWF.TextBoxBase)	105	if (Provider.Control is SWF.TextBoxBase)
106	return (SWF.TextBoxBase)Provider.Control;	106	return (SWF.TextBoxBase)Provider.Control;
107	else if (Provider.Control is SWF.UpDownBase)	107	else if (Provider.Control is SWF.UpDownBase)
108	return ((SWF.UpDownBase)Provider.Control).txtView;	108	return ((SWF.UpDownBase)Provider.Control).InvokeSync (c => c.txtView);
109	else	109	else
110	throw new Exception ("TextBoxBase: Unknown type: " + Provider.Control);	110	throw new Exception ("TextBoxBase: Unknown type: " + Provider.Control);
111	}	111	}
Lines 114-124 namespace Mono.UIAutomation.Winforms.Behaviors.TextBox Link Here
114	private string Text {	114	private string Text {
115	get {	115	get {
116	if (TextBoxBase is SWF.MaskedTextBox)	116	if (TextBoxBase is SWF.MaskedTextBox)
117	return ((SWF.MaskedTextBox) TextBoxBase).MaskedTextProvider.ToDisplayString ();	117	return ((SWF.MaskedTextBox) TextBoxBase).InvokeSync (c => c.MaskedTextProvider.ToDisplayString ());
118	else	118	else
119	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; });
120	}	124	}
121	set { TextBoxBase.Text = value; }
122	}	125	}
123		126
124	}	127	}

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ToolBar/ToolBarButtonToggleProviderBehavior.cs (-4 / +5 lines)
79	public ToggleState ToggleState	79	public ToggleState ToggleState
80	{	80	{
81	get {	81	get {
82	return Helper.SynchronizedGet<SWF.ToolBar, ToggleState> (	82	if (toolBar.InvokeSync (t => toolBarButton.Pushed))
83	toolBar, t => toolBarButton.Pushed ? ToggleState.On : ToggleState.Off	83	return ToggleState.On;
84	);	84	else
		85	return ToggleState.Off;
85	}	86	}
86	}	87	}
87		88
Lines 90-96 namespace Mono.UIAutomation.Winforms.Behaviors.ToolBar Link Here
90	if (!toolBarButton.Enabled)	91	if (!toolBarButton.Enabled)
91	throw new ElementNotEnabledException ();	92	throw new ElementNotEnabledException ();
92		93
93	Helper.SynchronizedSet (toolBar, delegate {	94	toolBar.InvokeSync (delegate {
94	toolBar.UIAPerformClick (toolBarButton);	95	toolBar.UIAPerformClick (toolBarButton);
95	});	96	});
96	}	97	}

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/ToolStripSplitButton/ExpandCollapseProviderBehavior.cs (-4 / +3 lines)
77	if (dropdown == null)	77	if (dropdown == null)
78	return ExpandCollapseState.Collapsed;	78	return ExpandCollapseState.Collapsed;
79		79
80	return Helper.SynchronizedGet<SWF.ToolStrip, ExpandCollapseState> (	80	return Owner.InvokeSync (o => dropdown.Visible ? ExpandCollapseState.Expanded
81	Owner, o => dropdown.Visible ? ExpandCollapseState.Expanded
82	: ExpandCollapseState.Collapsed	81	: ExpandCollapseState.Collapsed
83	);	82	);
84	}	83	}
Lines 86-99 namespace Mono.UIAutomation.Winforms.Behaviors.ToolStripSplitButton Link Here
86		85
87	public void Collapse ()	86	public void Collapse ()
88	{	87	{
89	Helper.SynchronizedSet (Owner, delegate {	88	Owner.InvokeSync (delegate {
90	((SWF.ToolStripSplitButton) Provider.Component).HideDropDown ();	89	((SWF.ToolStripSplitButton) Provider.Component).HideDropDown ();
91	});	90	});
92	}	91	}
93		92
94	public void Expand ()	93	public void Expand ()
95	{	94	{
96	Helper.SynchronizedSet (Owner, delegate {	95	Owner.InvokeSync (delegate {
97	((SWF.ToolStripSplitButton) Provider.Component).ShowDropDown ();	96	((SWF.ToolStripSplitButton) Provider.Component).ShowDropDown ();
98	});	97	});
99	}	98	}

Lines 92-98 namespace Mono.UIAutomation.Winforms.Behaviors.TreeView Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/TreeView/SelectionProviderBehavior.cs (-4 / +2 lines)
92		92
93	public IRawElementProviderSimple [] GetSelection ()	93	public IRawElementProviderSimple [] GetSelection ()
94	{	94	{
95	SWF.TreeNode selectedNode = treeView.SelectedNode;	95	SWF.TreeNode selectedNode = treeView.InvokeSync (c => c.SelectedNode);
96	TreeNodeProvider selectedNodeProvider = null;	96	TreeNodeProvider selectedNodeProvider = null;
97		97
98	if (selectedNode != null)	98	if (selectedNode != null)
Lines 110-118 namespace Mono.UIAutomation.Winforms.Behaviors.TreeView Link Here
110		110
111	public bool IsSelectionRequired {	111	public bool IsSelectionRequired {
112	get {	112	get {
113	return Helper.SynchronizedGet<SWF.TreeView, bool> (	113	return treeView.InvokeSync (t => t.SelectedNode != null);
114	treeView, t => t.SelectedNode != null
115	);
116	}	114	}
117	}	115	}
118		116

Lines 82-110 namespace Mono.UIAutomation.Winforms.Behaviors.UpDownBase Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Behaviors/UpDownBase/ValueProviderBehavior.cs (-15 / +5 lines)
82	#region IValueProvider Members	82	#region IValueProvider Members
83		83
84	public bool IsReadOnly {	84	public bool IsReadOnly {
85	get {	85	get { return upDownBase.InvokeSync (c => c.ReadOnly); }
86	return Helper.SynchronizedGet<SWF.UpDownBase, bool> (
87	(SWF.UpDownBase) Provider.Control, u => u.ReadOnly
88	);
89	}
90	}	86	}
91		87
92	public string Value {	88	public string Value {
93	get {	89	get { return upDownBase.InvokeSync (c => c.Text); }
94	return Helper.SynchronizedGet<SWF.UpDownBase, string> (
95	(SWF.UpDownBase) Provider.Control, u => u.Text
96	);
97	}
98	}	90	}
99		91
100	public void SetValue (string value)	92	public void SetValue (string value)
101	{	93	{
102	if (!upDownBase.Enabled \|\| upDownBase.ReadOnly)	94	if (upDownBase.InvokeSync (c => !c.Enabled \|\| c.ReadOnly))
103	throw new ElementNotEnabledException ();	95	throw new ElementNotEnabledException ();
104		96
105	Helper.SynchronizedSet (upDownBase, delegate {	97	upDownBase.InvokeSync (delegate { upDownBase.Text = value; });
106	upDownBase.Text = value;
107	});
108	}	98	}
109		99
110	#endregion	100	#endregion

Lines 48-73 namespace Mono.UIAutomation.Winforms.Events Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/AutomationIsOffscreenPropertyEvent.cs (-4 / +4 lines)
48		48
49	public override void Connect ()	49	public override void Connect ()
50	{	50	{
51	// Helper.SynchronizedSet (Provider.Control, delegate {	51	Provider.Control.InvokeSync (delegate {
52	Provider.Control.Resize += new EventHandler (OnIsOffScreen);	52	Provider.Control.Resize += new EventHandler (OnIsOffScreen);
53	Provider.Control.LocationChanged += new EventHandler (OnIsOffScreen);	53	Provider.Control.LocationChanged += new EventHandler (OnIsOffScreen);
54	if (Provider.Control.Parent != null)	54	if (Provider.Control.Parent != null)
55	Provider.Control.Parent.LocationChanged += new EventHandler (OnIsOffScreen);	55	Provider.Control.Parent.LocationChanged += new EventHandler (OnIsOffScreen);
56	if (Provider.Control.FindForm () != null)	56	if (Provider.Control.FindForm () != null)
57	Provider.Control.FindForm ().Resize += new EventHandler (OnIsOffScreen);	57	Provider.Control.FindForm ().Resize += new EventHandler (OnIsOffScreen);
58	// });	58	});
59	}	59	}
60		60
61	public override void Disconnect ()	61	public override void Disconnect ()
62	{	62	{
63	// Helper.SynchronizedSet (Provider.Control, delegate {	63	Provider.Control.InvokeSync (delegate {
64	Provider.Control.Resize -= new EventHandler (OnIsOffScreen);	64	Provider.Control.Resize -= new EventHandler (OnIsOffScreen);
65	Provider.Control.LocationChanged -= new EventHandler (OnIsOffScreen);	65	Provider.Control.LocationChanged -= new EventHandler (OnIsOffScreen);
66	if (Provider.Control.Parent != null)	66	if (Provider.Control.Parent != null)
67	Provider.Control.Parent.LocationChanged -= new EventHandler (OnIsOffScreen);	67	Provider.Control.Parent.LocationChanged -= new EventHandler (OnIsOffScreen);
68	if (Provider.Control.FindForm () != null)	68	if (Provider.Control.FindForm () != null)
69	Provider.Control.FindForm ().Resize -= new EventHandler (OnIsOffScreen);	69	Provider.Control.FindForm ().Resize -= new EventHandler (OnIsOffScreen);
70	// });	70	});
71	}	71	}
72		72
73	#endregion	73	#endregion

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

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

Lines 69-85 namespace Mono.UIAutomation.Winforms.Events Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Events/BaseAutomationPropertyEvent.cs (-11 / +7 lines)
69	object newValue = GetNewPropertyValue ();	69	object newValue = GetNewPropertyValue ();
70		70
71	if (object.Equals (OldValue, newValue) == false) {	71	if (object.Equals (OldValue, newValue) == false) {
72	object oldValue = newValue;	72	AutomationPropertyChangedEventArgs args =
73	OldValue = oldValue;	73	new AutomationPropertyChangedEventArgs (Property,
74	Helper.DelegateQueue.Get ().Enqueue (delegate {	74	OldValue,
75	// System.Threading.ThreadPool.QueueUserWorkItem (v => {	75	newValue);
76	AutomationPropertyChangedEventArgs args =	76	AutomationInteropProvider.RaiseAutomationPropertyChangedEvent (Provider,
77	new AutomationPropertyChangedEventArgs (Property,	77	args);
78	oldValue,	78	OldValue = newValue;
79	newValue);
80	AutomationInteropProvider.RaiseAutomationPropertyChangedEvent (Provider,
81	args);
82	});
83	}	79	}
84	}	80	}
85	}	81	}

Lines 163-197 namespace Mono.UIAutomation.Winforms.Navigation Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.Navigation/ParentNavigation.cs (-6 / +6 lines)
163		163
164		164
165	if (args.RaiseEvent == true) {	165	if (args.RaiseEvent == true) {
166	Helper.DelegateQueue.Get ().Enqueue (delegate {	166	// Helper.DelegateQueue.Get ().Enqueue (delegate {
167	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildAdded,	167	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildAdded,
168	args.ChildProvider);	168	args.ChildProvider);
169	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildrenInvalidated,	169	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildrenInvalidated,
170	(FragmentControlProvider) sender);	170	(FragmentControlProvider) sender);
171	});	171	// });
172	}	172	}
173	} else if (args.ChangeType == StructureChangeType.ChildRemoved) {	173	} else if (args.ChangeType == StructureChangeType.ChildRemoved) {
174	Remove (args.ChildProvider.Navigation);	174	Remove (args.ChildProvider.Navigation);
175		175
176	if (args.RaiseEvent == true) {	176	if (args.RaiseEvent == true) {
177	Helper.DelegateQueue.Get ().Enqueue (delegate {	177	// Helper.DelegateQueue.Get ().Enqueue (delegate {
178	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildRemoved,	178	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildRemoved,
179	args.ChildProvider);	179	args.ChildProvider);
180	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildrenInvalidated,	180	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildrenInvalidated,
181	(FragmentControlProvider) sender);	181	(FragmentControlProvider) sender);
182	});	182	// });
183	}	183	}
184	} else if (args.ChangeType == StructureChangeType.ChildrenReordered) {	184	} else if (args.ChangeType == StructureChangeType.ChildrenReordered) {
185	chain.Clear ();	185	chain.Clear ();
186		186
187	//TODO: Is this the event to generate?	187	//TODO: Is this the event to generate?
188	if (args.RaiseEvent == true) {	188	if (args.RaiseEvent == true) {
189	Helper.DelegateQueue.Get ().Enqueue (delegate {	189	// Helper.DelegateQueue.Get ().Enqueue (delegate {
190	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildrenBulkRemoved,	190	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildrenBulkRemoved,
191	(FragmentControlProvider) sender);	191	(FragmentControlProvider) sender);
192	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildrenInvalidated,	192	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildrenInvalidated,
193	(FragmentControlProvider) sender);	193	(FragmentControlProvider) sender);
194	});	194	// });
195	}	195	}
196	}	196	}
197	}	197	}

Lines 1-4 Link Here

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms.mdp (-3 / +10 lines)
1	<Project name="Mono.UIAutomation.Winforms" fileversion="2.0" language="C#" UseParentDirectoryAsNamespace="True" DefaultNamespace="Mono.UIAutomation.Winforms" clr-version="Net_2_0" targetFramework="3.5" ctype="DotNetProject">	1	<Project name="Mono.UIAutomation.Winforms" fileversion="2.0" language="C#" DefaultNamespace="Mono.UIAutomation.Winforms" UseParentDirectoryAsNamespace="True" clr-version="Net_2_0" targetFramework="3.5" ctype="DotNetProject">
2	<Configurations active="Debug">	2	<Configurations active="Debug">
3	<Configuration name="Debug" ctype="DotNetProjectConfiguration">	3	<Configuration name="Debug" ctype="DotNetProjectConfiguration">
4	<Output directory="bin/Debug" signAssembly="True" assemblyKeyFile="../mono-uia.snk" assembly="UIAutomationWinforms" />	4	<Output directory="bin/Debug" signAssembly="True" assemblyKeyFile="../mono-uia.snk" assembly="UIAutomationWinforms" />
Lines 23-29 Link Here
23	<File name="Mono.UIAutomation.Winforms/RadioButtonProvider.cs" subtype="Code" buildaction="Compile" />	23	<File name="Mono.UIAutomation.Winforms/RadioButtonProvider.cs" subtype="Code" buildaction="Compile" />
24	<File name="Mono.UIAutomation.Winforms/LabelProvider.cs" subtype="Code" buildaction="Compile" />	24	<File name="Mono.UIAutomation.Winforms/LabelProvider.cs" subtype="Code" buildaction="Compile" />
25	<File name="Mono.UIAutomation.Winforms/TextBoxProvider.cs" subtype="Code" buildaction="Compile" />	25	<File name="Mono.UIAutomation.Winforms/TextBoxProvider.cs" subtype="Code" buildaction="Compile" />
26	<File name="Mono.UIAutomation.Winforms/Helper.cs" subtype="Code" buildaction="Compile" />
27	<File name="Mono.UIAutomation.Winforms/LinkLabelProvider.cs" subtype="Code" buildaction="Compile" />	26	<File name="Mono.UIAutomation.Winforms/LinkLabelProvider.cs" subtype="Code" buildaction="Compile" />
28	<File name="Mono.UIAutomation.Winforms.Events/AutomationHasKeyboardFocusPropertyEvent.cs" subtype="Code" buildaction="Compile" />	27	<File name="Mono.UIAutomation.Winforms.Events/AutomationHasKeyboardFocusPropertyEvent.cs" subtype="Code" buildaction="Compile" />
29	<File name="Mono.UIAutomation.Winforms.Events/AutomationBoundingRectanglePropertyEvent.cs" subtype="Code" buildaction="Compile" />	28	<File name="Mono.UIAutomation.Winforms.Events/AutomationBoundingRectanglePropertyEvent.cs" subtype="Code" buildaction="Compile" />
Lines 567-572 Link Here
567	<File name="Mono.UIAutomation.Winforms.Events/DataGridView/DataItemChildHasKeyboardFocusPropertyEvent.cs" subtype="Code" buildaction="Compile" />	566	<File name="Mono.UIAutomation.Winforms.Events/DataGridView/DataItemChildHasKeyboardFocusPropertyEvent.cs" subtype="Code" buildaction="Compile" />
568	<File name="Mono.UIAutomation.Winforms.Behaviors/DataGrid/DataItemEditSelectionItemProviderBehavior.cs" subtype="Code" buildaction="Compile" />	567	<File name="Mono.UIAutomation.Winforms.Behaviors/DataGrid/DataItemEditSelectionItemProviderBehavior.cs" subtype="Code" buildaction="Compile" />
569	<File name="Mono.UIAutomation.Winforms.Events/DataGrid/DataItemEditSelectionItemPatternIsSelectedEvent.cs" subtype="Code" buildaction="Compile" />	568	<File name="Mono.UIAutomation.Winforms.Events/DataGrid/DataItemEditSelectionItemPatternIsSelectedEvent.cs" subtype="Code" buildaction="Compile" />
		569	<File name="Mono.UIAutomation.Winforms.Behaviors/ListView/ListItemInvokeProviderBehavior.cs" subtype="Code" buildaction="Compile" />
		570	<File name="Mono.UIAutomation.Winforms.Behaviors/ToolStripButton/ToggleProviderBehavior.cs" subtype="Code" buildaction="Compile" />
		571	<File name="Mono.UIAutomation.Winforms.Events/DateTimePicker/CheckboxAutomationHasKeyboardFocusPropertyEvent.cs" subtype="Code" buildaction="Compile" />
		572	<File name="Mono.UIAutomation.Winforms.Events/DateTimePicker/PartAutomationHasKeyboardFocusPropertyEvent.cs" subtype="Code" buildaction="Compile" />
		573	<File name="Mono.UIAutomation.Winforms.Events/MonthCalendar/AutomationNamePropertyEvent.cs" subtype="Code" buildaction="Compile" />
		574	<File name="Mono.UIAutomation.Winforms.Events/PopupButton/AutomationHasKeyboardFocusPropertyEvent.cs" subtype="Code" buildaction="Compile" />
		575	<File name="Mono.UIAutomation.Winforms.Events/ToolStripButton/TogglePatternToggleStateEvent.cs" subtype="Code" buildaction="Compile" />
		576	<File name="Mono.UIAutomation.Winforms/Helper.cs" subtype="Code" buildaction="Compile" />
570	</Contents>	577	</Contents>
571	<References>	578	<References>
572	<ProjectReference type="Gac" localcopy="True" refto="System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />	579	<ProjectReference type="Gac" localcopy="True" refto="System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
Lines 578-587 Link Here
578	<ProjectReference type="Gac" localcopy="True" refto="System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />	585	<ProjectReference type="Gac" localcopy="True" refto="System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
579	<ProjectReference type="Gac" localcopy="True" refto="UIAutomationTypes, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />	586	<ProjectReference type="Gac" localcopy="True" refto="UIAutomationTypes, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
580	<ProjectReference type="Gac" localcopy="True" refto="UIAutomationProvider, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />	587	<ProjectReference type="Gac" localcopy="True" refto="UIAutomationProvider, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
		588	<ProjectReference type="Gac" localcopy="True" refto="System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
581	<ProjectReference type="Gac" localcopy="True" refto="glib-sharp, Version=2.14.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" />	589	<ProjectReference type="Gac" localcopy="True" refto="glib-sharp, Version=2.14.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" />
582	<ProjectReference type="Gac" localcopy="True" refto="atk-sharp, Version=2.14.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" />	590	<ProjectReference type="Gac" localcopy="True" refto="atk-sharp, Version=2.14.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" />
583	<ProjectReference type="Gac" localcopy="True" refto="Mono.WebBrowser, Version=0.5.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756" />	591	<ProjectReference type="Gac" localcopy="True" refto="Mono.WebBrowser, Version=0.5.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756" />
584	<ProjectReference type="Gac" localcopy="True" refto="System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
585	</References>	592	</References>
586	<MonoDevelop.Autotools.MakefileInfo IntegrationEnabled="True" RelativeMakefileName="Makefile.am" IsAutotoolsProject="True" RelativeConfigureInPath="..">	593	<MonoDevelop.Autotools.MakefileInfo IntegrationEnabled="True" RelativeMakefileName="Makefile.am" IsAutotoolsProject="True" RelativeConfigureInPath="..">
587	<BuildFilesVar Sync="True" Name="FILES" />	594	<BuildFilesVar Sync="True" Name="FILES" />

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/FormProvider.cs (-11 / +7 lines)
59		59
60	// We keep a copy because we can't reference "form" after	60	// We keep a copy because we can't reference "form" after
61	// Disposed (used in Close()) called by WindowPatternWindowClosedEvent.	61	// Disposed (used in Close()) called by WindowPatternWindowClosedEvent.
62	owner = Helper.SynchronizedGet<Form, Form> (form, o => form.Owner);	62	owner = form.InvokeSync (c => c.Owner);
63	alreadyClosed = false;	63	alreadyClosed = false;
64	}	64	}
65		65
Lines 153-164 namespace Mono.UIAutomation.Winforms Link Here
153		153
154	public override IRawElementProviderFragment ElementProviderFromPoint (double x, double y)	154	public override IRawElementProviderFragment ElementProviderFromPoint (double x, double y)
155	{	155	{
156	if (Helper.SynchronizedGet<Form, bool> (form,	156	if (form.InvokeSync (c => x > c.Width \|\| y > c.Height))
157	b => x > form.Width \|\| y > form.Height))
158	return null;	157	return null;
159		158
160	Control child = Helper.SynchronizedGet<Form, Control> (form,	159	Control child
161	c => form.GetChildAtPoint (new Point ((int) x, (int) y)));	160	= form.InvokeSync (c => c.GetChildAtPoint (new Point ((int) x, (int) y)));
162		161
163	if (child != null) {	162	if (child != null) {
164	Log.Debug (child.ToString ());	163	Log.Debug (child.ToString ());
Lines 179-187 namespace Mono.UIAutomation.Winforms Link Here
179		178
180	public override IRawElementProviderFragment GetFocus ()	179	public override IRawElementProviderFragment GetFocus ()
181	{	180	{
182	foreach (Control control	181	foreach (Control control in form.InvokeSync (f => f.Controls)) {
183	in Helper.SynchronizedGet<Form, Control.ControlCollection> (form, f => f.Controls)) {	182	if (control.InvokeSync (c => c.Focused)) {
184	if (control.Focused) {
185	// TODO: Necessary to delve into child control	183	// TODO: Necessary to delve into child control
186	// for focused element?	184	// for focused element?
187		185
Lines 209-218 namespace Mono.UIAutomation.Winforms Link Here
209	alreadyClosed = true;	207	alreadyClosed = true;
210		208
211	if (owner == null) {	209	if (owner == null) {
212	Helper.DelegateQueue.Get ().Enqueue (delegate {
213	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildRemoved,	210	Helper.RaiseStructureChangedEvent (StructureChangeType.ChildRemoved,
214	this);	211	this);
215	});
216	} else {	212	} else {
217	FormProvider ownerProvider	213	FormProvider ownerProvider
218	= ProviderFactory.FindProvider (owner) as FormProvider;	214	= ProviderFactory.FindProvider (owner) as FormProvider;
Lines 224-230 namespace Mono.UIAutomation.Winforms Link Here
224		220
225	private void SetupMainMenuProvider ()	221	private void SetupMainMenuProvider ()
226	{	222	{
227	MainMenu mainMenu = Helper.SynchronizedGet<Form, MainMenu> (form, m => form.Menu);	223	MainMenu mainMenu = form.InvokeSync (f => f.Menu);
228		224
229	if (mainMenu != null) {	225	if (mainMenu != null) {
230	mainMenuProvider = (MainMenuProvider)	226	mainMenuProvider = (MainMenuProvider)

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/FragmentControlProvider.cs (-16 / +16 lines)
66	children = new List<FragmentControlProvider> ();	66	children = new List<FragmentControlProvider> ();
67	componentChildren = new List<Component> ();	67	componentChildren = new List<Component> ();
68		68
69	// if (Control != null) {	69	if (Control != null) {
70	// Control.ContextMenuChanged += HandleContextMenuChanged;	70	Control.ContextMenuChanged += HandleContextMenuChanged;
71	// Control.ContextMenuStripChanged += HandleContextMenuStripChanged;	71	Control.ContextMenuStripChanged += HandleContextMenuStripChanged;
72	//	72
73	// HandleContextMenuChanged (null, EventArgs.Empty);	73	HandleContextMenuChanged (null, EventArgs.Empty);
74	// HandleContextMenuStripChanged (null, EventArgs.Empty);	74	HandleContextMenuStripChanged (null, EventArgs.Empty);
75	//	75
76	// visible = Helper.SynchronizedGet<SWF.Control, bool> (Control, v => Control.Visible);	76	visible = Control.InvokeSync (c => c.Visible);
77	// }	77	}
78	}	78	}
79		79
80	void HandleContextMenuStripChanged (object sender, EventArgs e)	80	void HandleContextMenuStripChanged (object sender, EventArgs e)
Lines 83-89 namespace Mono.UIAutomation.Winforms Link Here
83	contextMenuStrip.Opened -= HandleContextMenuStripOpened;	83	contextMenuStrip.Opened -= HandleContextMenuStripOpened;
84	contextMenuStrip.Closed -= HandleContextMenuStripClosed;	84	contextMenuStrip.Closed -= HandleContextMenuStripClosed;
85	}	85	}
86	contextMenuStrip = Helper.SynchronizedGet<SWF.Control, SWF.ContextMenuStrip> (Control, m => Control.ContextMenuStrip);	86	contextMenuStrip = Control.InvokeSync (c => c.ContextMenuStrip);
87		87
88	if (contextMenuStrip != null) {	88	if (contextMenuStrip != null) {
89	contextMenuStrip.Opened += HandleContextMenuStripOpened;	89	contextMenuStrip.Opened += HandleContextMenuStripOpened;
Lines 116-122 namespace Mono.UIAutomation.Winforms Link Here
116	contextMenu.Popup -= HandleContextMenuPopup;	116	contextMenu.Popup -= HandleContextMenuPopup;
117	contextMenu.Collapse -= HandleContextMenuCollapse;	117	contextMenu.Collapse -= HandleContextMenuCollapse;
118	}	118	}
119	contextMenu = Helper.SynchronizedGet<SWF.Control, SWF.ContextMenu> (Control, c => c.ContextMenu);	119	contextMenu = Control.InvokeSync (c => c.ContextMenu);
120		120
121	if (contextMenu != null) {	121	if (contextMenu != null) {
122	contextMenu.Popup += HandleContextMenuPopup;	122	contextMenu.Popup += HandleContextMenuPopup;
Lines 271-277 namespace Mono.UIAutomation.Winforms Link Here
271	HandleContextMenuChanged (null, EventArgs.Empty);	271	HandleContextMenuChanged (null, EventArgs.Empty);
272	HandleContextMenuStripChanged (null, EventArgs.Empty);	272	HandleContextMenuStripChanged (null, EventArgs.Empty);
273		273
274	visible = Helper.SynchronizedGet<SWF.Control, bool> (Control, v => Control.Visible);	274	visible = Control.InvokeSync (c => c.Visible);
275	}	275	}
276	}	276	}
277		277
Lines 291-297 namespace Mono.UIAutomation.Winforms Link Here
291	Control.ControlAdded += OnControlAdded;	291	Control.ControlAdded += OnControlAdded;
292	Control.ControlRemoved += OnControlRemoved;	292	Control.ControlRemoved += OnControlRemoved;
293		293
294	foreach (SWF.Control childControl in Control.Controls)	294	foreach (SWF.Control childControl in Control.InvokeSync (c => c.Controls))
295	HandleComponentAdded (childControl);	295	HandleComponentAdded (childControl);
296		296
297	Control.VisibleChanged += OnControlVisibleChanged;	297	Control.VisibleChanged += OnControlVisibleChanged;
Lines 349-355 namespace Mono.UIAutomation.Winforms Link Here
349		349
350	private void OnControlVisibleChanged (object sender, EventArgs args)	350	private void OnControlVisibleChanged (object sender, EventArgs args)
351	{	351	{
352	bool isVisible = Helper.SynchronizedGet<SWF.Control, bool> (Control, v => v.Visible);	352	bool isVisible = Control.InvokeSync (c => c.Visible);
353		353
354	if (visible == isVisible)	354	if (visible == isVisible)
355	return;	355	return;
Lines 479-485 namespace Mono.UIAutomation.Winforms Link Here
479	{	479	{
480	SWF.Control control = null;	480	SWF.Control control = null;
481	if ((control = component as SWF.Control) != null)	481	if ((control = component as SWF.Control) != null)
482	return control.Visible;	482	return control.InvokeSync (c => c.Visible);
483	else // Component based providers will need to override this method	483	else // Component based providers will need to override this method
484	return false;	484	return false;
485	}	485	}
Lines 539-545 namespace Mono.UIAutomation.Winforms Link Here
539	public virtual void SetFocus ()	539	public virtual void SetFocus ()
540	{	540	{
541	if (Control != null)	541	if (Control != null)
542	Helper.SynchronizedSet (Control, delegate { Control.Focus (); });	542	Control.InvokeSync (delegate { Control.Focus (); });
543	}	543	}
544		544
545	#endregion	545	#endregion

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

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

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

(-)a/UIAutomationWinforms/UIAutomationWinforms/Mono.UIAutomation.Winforms/ScrollBehaviorObserver.cs (-2 / +2 lines)
58	public bool HasHorizontalScrollbar {	58	public bool HasHorizontalScrollbar {
59	get {	59	get {
60	return HorizontalScrollBar != null	60	return HorizontalScrollBar != null
61	&& HorizontalScrollBar.Visible && HorizontalScrollBar.Enabled;	61	&& HorizontalScrollBar.InvokeSync (c => c.Visible && c.Enabled);
62	}	62	}
63	}	63	}
64		64
65	public bool HasVerticalScrollbar {	65	public bool HasVerticalScrollbar {
66	get {	66	get {
67	return VerticalScrollBar != null	67	return VerticalScrollBar != null
68	&& VerticalScrollBar.Visible && VerticalScrollBar.Enabled;	68	&& VerticalScrollBar.InvokeSync (c => c.Visible && c.Enabled);
69	}	69	}
70	}	70	}
71		71