linux-packaging-mono/mcs/class/Managed.Windows.Forms/System.Windows.Forms/LinkLabel.cs

// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// Copyright (c) 2004-2005 Novell, Inc.
//
// Authors:
//	Jordi Mas i Hernandez, jordi@ximian.com
//	Chris Toshok  <toshok@ximian.com>
//	Everaldo Canuto  <ecanuto@novell.com>
//
// Based on work by:
//	Daniel Carrera, dcarrera@math.toronto.edu (stubbed out)
//	Jaak Simm (jaaksimm@firm.ee) (stubbed out)
//

using System.ComponentModel;
using System.Collections;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Runtime.InteropServices;
using System.Windows.Forms.Theming;

namespace System.Windows.Forms
{
	[DefaultEvent("LinkClicked")]
	[ClassInterface (ClassInterfaceType.AutoDispatch)]
	[ComVisible (true)]
	[ToolboxItem ("System.Windows.Forms.Design.AutoSizeToolboxItem," + Consts.AssemblySystem_Design)]
	public class LinkLabel : Label, IButtonControl
	{
		/* Encapsulates a piece of text (regular or link)*/
		internal class Piece
		{
			public string		text;
			public int		start;
			public int		length;
			public LinkLabel.Link	link;	// Empty link indicates regular text
			public Region           region;

			public Piece (int start, int length, string text, Link link)
			{
				this.start = start;
				this.length = length;
				this.text = text;
				this.link = link;
			}
		}

		private Color active_link_color;
		private Color disabled_link_color;
		private Color link_color;
		private Color visited_color;
		private LinkArea link_area;
		private LinkBehavior link_behavior;
		private LinkCollection link_collection;
		private ArrayList links = new ArrayList();
		internal Link[] sorted_links;
		private bool link_visited;
		internal Piece[] pieces;
		private Cursor override_cursor;
		private DialogResult dialog_result;

		private Link active_link;
		private Link hovered_link;
		/* this is an index instead of a Link because we have
		 * to search through sorted links for the new one */
		private int focused_index;

		#region Events
		static object LinkClickedEvent = new object ();

		public event LinkLabelLinkClickedEventHandler LinkClicked {
			add { Events.AddHandler (LinkClickedEvent, value); }
			remove { Events.RemoveHandler (LinkClickedEvent, value); }
		}

		[Browsable (true)]
		[EditorBrowsable (EditorBrowsableState.Always)]
		public new event EventHandler TabStopChanged {
			add { base.TabStopChanged += value; }
			remove { base.TabStopChanged -= value; }
		}
		#endregion // Events

		public LinkLabel ()
		{
			LinkArea = new LinkArea (0, -1);
			link_behavior = LinkBehavior.SystemDefault;
			link_visited = false;
			pieces = null;
			focused_index = -1;

			string_format.FormatFlags |= StringFormatFlags.NoClip;
			
			ActiveLinkColor = Color.Red;
			DisabledLinkColor = ThemeEngine.Current.ColorGrayText;
			LinkColor = Color.FromArgb (255, 0, 0, 255);
			VisitedLinkColor = Color.FromArgb (255, 128, 0, 128);
			SetStyle (ControlStyles.Selectable, false);
			SetStyle (ControlStyles.ResizeRedraw | 
				ControlStyles.UserPaint | 
				ControlStyles.AllPaintingInWmPaint |
				ControlStyles.SupportsTransparentBackColor | 
				ControlStyles.Opaque |
				ControlStyles.OptimizedDoubleBuffer
				, true);
			CreateLinkPieces ();
		}

		#region Public Properties

		public Color ActiveLinkColor {
			get { return active_link_color; }
			set {
				if (active_link_color == value)
					return;

				active_link_color = value;
				Invalidate ();
			}
		}

		public Color DisabledLinkColor {

			get { return disabled_link_color; }
			set {
				if (disabled_link_color == value)
					return;

				disabled_link_color = value;
				Invalidate ();
			}
		}

		public Color LinkColor {
			get { return link_color; }
			set {
				if (link_color == value)
					return;

				link_color = value;
				Invalidate ();
			}
		}

		public Color VisitedLinkColor {
			get { return visited_color;}
			set {
				if (visited_color == value)
					return;

				visited_color = value;
				Invalidate ();
			}
		}

		[Localizable (true)]
		[Editor ("System.Windows.Forms.Design.LinkAreaEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]				
		[RefreshProperties (RefreshProperties.Repaint)]
		public LinkArea LinkArea {
			get { return link_area;}
			set {

				if (value.Start <0 || value.Length < -1)
					throw new ArgumentException ();

				Links.Clear ();

				if (!value.IsEmpty) {
					Links.Add (value.Start, value.Length);

					link_area = value;
					Invalidate ();
				}
			}
		}
				
		[DefaultValue (LinkBehavior.SystemDefault)]
		public LinkBehavior LinkBehavior {

			get { return link_behavior;}
			set {
				if (link_behavior == value)
					return;

				link_behavior = value;
				Invalidate ();
			}
		}
	
		[Browsable (false)]
		[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
		public LinkLabel.LinkCollection Links {
			get {
				if (link_collection == null)
					link_collection = new LinkCollection (this);
				return link_collection;
			}
		}

		[DefaultValue (false)]
		public bool LinkVisited {
			get { return link_visited;}
			set {
				if (link_visited == value)
					return;

				link_visited = value;
				Invalidate ();
			}
		}
		
		protected Cursor OverrideCursor {
			get {
				if (override_cursor == null)
					override_cursor = Cursors.Hand;
				return override_cursor;
			}
			set { override_cursor = value; }
		}

		[RefreshProperties(RefreshProperties.Repaint)]
		public override string Text {
			get { return base.Text; }
			set {
				if (base.Text == value)
					return;

				base.Text = value;
				CreateLinkPieces ();
			}
		}

		[Browsable (false)]
		[EditorBrowsable (EditorBrowsableState.Never)]
		public new FlatStyle FlatStyle {
			get { return base.FlatStyle; }
			set {
				if (base.FlatStyle == value)
					return;

				base.FlatStyle = value;
			}
		}

		[RefreshProperties (RefreshProperties.Repaint)]
		public new Padding Padding {
			get { return base.Padding; }
			set {
				if (base.Padding == value)
					return;

				base.Padding = value;
				CreateLinkPieces ();
			}
		}

		#endregion // Public Properties

		DialogResult IButtonControl.DialogResult {
			get { return dialog_result; }
			set { dialog_result = value; }
		}


		void IButtonControl.NotifyDefault (bool value)
		{
		}

		void IButtonControl.PerformClick ()
		{
		}

		#region Public Methods
		protected override AccessibleObject CreateAccessibilityInstance ()
		{
			return base.CreateAccessibilityInstance();
		}

		protected override void CreateHandle ()
		{
			base.CreateHandle ();
			CreateLinkPieces ();
		}

		protected override void OnAutoSizeChanged (EventArgs e)
		{
			base.OnAutoSizeChanged (e);
		}

		protected override void OnEnabledChanged (EventArgs e)
		{
			base.OnEnabledChanged (e);
			Invalidate ();
		}

		protected override void OnFontChanged (EventArgs e)
		{
			base.OnFontChanged (e);
			CreateLinkPieces ();
		}

		protected override void OnGotFocus (EventArgs e)
		{
			base.OnGotFocus (e);
			
			// And yes it can actually be null..... arghh..
			if (sorted_links == null)
				return;

			// Set focus to the first enabled link piece
			if (focused_index == -1) {
				if ((Control.ModifierKeys & Keys.Shift) == 0) {
					for (int i = 0; i < sorted_links.Length; i ++) {
						if (sorted_links[i].Enabled) {
							focused_index = i;
							break;
						}
					}
				} else {
					if (focused_index == -1)
						focused_index = sorted_links.Length;

					for (int n = focused_index - 1; n >= 0; n--) {
						if (sorted_links[n].Enabled) {
							sorted_links[n].Focused = true;
							focused_index = n;
							return;
						}
					}
				}
			}

			if (focused_index != -1)
				sorted_links[focused_index].Focused = true;
		}

		protected override void OnKeyDown (KeyEventArgs e)
		{
			if (e.KeyCode == Keys.Return) {
				if (focused_index != -1)
					OnLinkClicked (new LinkLabelLinkClickedEventArgs (sorted_links[focused_index]));
			}

			base.OnKeyDown(e);
		}

		protected virtual void OnLinkClicked (LinkLabelLinkClickedEventArgs e)
		{
			LinkLabelLinkClickedEventHandler eh = (LinkLabelLinkClickedEventHandler)(Events [LinkClickedEvent]);
			if (eh != null)
				eh (this, e);
		}

		protected override void OnLostFocus (EventArgs e)
		{
			base.OnLostFocus (e);
			
			// Clean focus in link pieces
			if (focused_index != -1)
				sorted_links[focused_index].Focused = false;
		}

		protected override void OnMouseDown (MouseEventArgs e)
		{
			if (!Enabled) return;

			base.OnMouseDown (e);

			for (int i = 0; i < sorted_links.Length; i ++) {
				if (sorted_links[i].Contains (e.X, e.Y) && sorted_links[i].Enabled) {
					sorted_links[i].Active = true;
					if (focused_index != -1)
						sorted_links[focused_index].Focused = false;
					active_link = sorted_links[i];
					focused_index = i;
					sorted_links[focused_index].Focused = true;
					break;
				}
			}
		}

		protected override void OnMouseLeave(EventArgs e)
		{
			if (!Enabled) return;
			base.OnMouseLeave (e);
			UpdateHover (null);
		}

		protected override void OnPaddingChanged (EventArgs e)
		{
			base.OnPaddingChanged (e);
		}

		private void UpdateHover (Link link)
		{
			if (link == hovered_link)
				return;

			if (hovered_link != null)
				hovered_link.Hovered = false;

			hovered_link = link;

			if (hovered_link != null)
				hovered_link.Hovered = true;

			Cursor = (hovered_link != null) ? OverrideCursor : Cursors.Default;

			/* XXX this shouldn't be here.  the
			 * Link.Invalidate machinery should be enough,
			 * but it seems the piece regions don't
			 * contain the area with the underline.  this
			 * can be seen easily when you click on a link
			 * and the focus rectangle shows up (it's too
			 * far up), and also the bottom few pixels of
			 * a linklabel aren't active when it comes to
			 * hovering */
			Invalidate ();
		}

		protected override void OnMouseMove (MouseEventArgs e)
		{
			UpdateHover (PointInLink (e.X, e.Y));
			base.OnMouseMove (e);
		}

		protected override void OnMouseUp (MouseEventArgs e)
		{
			if (!Enabled) return;

			base.OnMouseUp (e);

			if (active_link == null)
				return;

			Link clicked_link = (PointInLink (e.X, e.Y) == active_link) ? active_link : null;

			active_link.Active = false;
			active_link = null;

			if (clicked_link != null)
				OnLinkClicked (new LinkLabelLinkClickedEventArgs (clicked_link, e.Button));
		}

		protected override void OnClick (EventArgs e)
		{
			if (active_link != null && this.Capture) {
				this.Capture = false;
			}
			base.OnClick (e);
		}

		protected override void OnPaint (PaintEventArgs e)
		{
			// We need to invoke paintbackground because control is opaque
			// and can have transparent colors.
			base.InvokePaintBackground (this, e);
			
			ThemeElements.LinkLabelPainter.Draw (e.Graphics, e.ClipRectangle, this);
			// Do not call base.OnPaint since it's the Label class 
		}

		protected override void OnPaintBackground (PaintEventArgs e)
		{
			base.OnPaintBackground (e);
		}

		protected override void OnTextAlignChanged (EventArgs e)
		{
			CreateLinkPieces ();
			base.OnTextAlignChanged (e);
		}

		protected override void OnTextChanged (EventArgs e)
		{
			CreateLinkPieces ();
			base.OnTextChanged (e);
		}
		
		protected Link PointInLink (int x, int y)
		{
			for (int i = 0; i < sorted_links.Length; i ++)
				if (sorted_links[i].Contains (x, y))
					return sorted_links[i];

			return null;
		}

		protected override bool ProcessDialogKey (Keys keyData)
		{
			if ((keyData & Keys.KeyCode) ==  Keys.Tab) {
				Select (true, (keyData & Keys.Shift) == 0);
				return true;
			}
			return base.ProcessDialogKey (keyData);
		}

		protected override void Select (bool directed, bool forward)
		{
			if (directed) {
				if (focused_index != -1) {
					sorted_links[focused_index].Focused = false;
					focused_index = -1;
				}

				if (forward) {
					for (int n = focused_index + 1; n < sorted_links.Length; n++) {
						if (sorted_links[n].Enabled) {
							sorted_links[n].Focused = true;
							focused_index = n;
							base.Select (directed, forward);
							return;
						}
					}
				} else {
					if (focused_index == -1)
						focused_index = sorted_links.Length;

					for (int n = focused_index - 1; n >= 0; n--) {
						if (sorted_links[n].Enabled) {
							sorted_links[n].Focused = true;
							focused_index = n;
							base.Select (directed, forward);
							return;
						}
					}
				}

				focused_index = -1;

				if (Parent != null)
					Parent.SelectNextControl (this, forward, false, true, true);
			}
		}

		protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified)
		{
			base.SetBoundsCore (x, y, width, height, specified);
			CreateLinkPieces();
		}

		protected override void WndProc (ref Message msg)
		{
			base.WndProc (ref msg);
		}

		#endregion //Public Methods

		#region Private Methods

		private ArrayList CreatePiecesFromText (int start, int len, Link link)
		{
			ArrayList rv = new ArrayList ();

			if (start + len > Text.Length)
				len = Text.Length - start;
			if (len < 0)
				return rv;

			string t = Text.Substring (start, len);

			int ps = 0;
			for (int i = 0; i < t.Length; i ++) {
				if (t[i] == '\n') {
					if (i != 0) {
						Piece p = new Piece (start + ps, i + 1 - ps, t.Substring (ps, i+1-ps), link);
						rv.Add (p);
					}
					ps = i+1;
				}
			}
			if (ps < t.Length) {
				Piece p = new Piece (start + ps, t.Length - ps, t.Substring (ps, t.Length-ps), link);
				rv.Add (p);
			}

			return rv;
		}

		private void CreateLinkPieces ()
		{
			if (Text.Length == 0) {
				SetStyle (ControlStyles.Selectable, false);
				TabStop = false;
				link_area.Start = 0;
				link_area.Length = 0;
				return;
			}
			
			if (Links.Count == 1 && Links[0].Start == 0 &&	Links[0].Length == -1)
				Links[0].Length = Text.Length;

			SortLinks ();

			// Set the LinkArea values based on first link.
			if (Links.Count > 0) {
				link_area.Start = Links[0].Start;
				link_area.Length = Links[0].Length;
			} else {
				link_area.Start = 0;
				link_area.Length = 0;
			}

			TabStop = (LinkArea.Length > 0);
			SetStyle (ControlStyles.Selectable, TabStop);

			/* don't bother doing the rest if our handle hasn't been created */
			if (!IsHandleCreated)
				return;

			ArrayList pieces_list = new ArrayList ();

			int current_end = 0;

			for (int l = 0; l < sorted_links.Length; l ++) {
				int new_link_start = sorted_links[l].Start;

				if (new_link_start > current_end) {
					/* create/push a piece
					 * containing the text between
					 * the previous/new link */
					ArrayList text_pieces = CreatePiecesFromText (current_end, new_link_start - current_end, null);
					pieces_list.AddRange (text_pieces);
				}

				/* now create a group of pieces for
				 * the new link (split up by \n's) */
				ArrayList link_pieces = CreatePiecesFromText (new_link_start, sorted_links[l].Length, sorted_links[l]);
				pieces_list.AddRange (link_pieces);
				sorted_links[l].pieces.AddRange (link_pieces);

				current_end = sorted_links[l].Start + sorted_links[l].Length;
			}
			if (current_end < Text.Length) {
				ArrayList text_pieces = CreatePiecesFromText (current_end, Text.Length - current_end, null);
				pieces_list.AddRange (text_pieces);
			}

			pieces = new Piece[pieces_list.Count];
			pieces_list.CopyTo (pieces, 0);

			CharacterRange[] ranges = new CharacterRange[pieces.Length];

			for(int i = 0; i < pieces.Length; i++)
				ranges[i] = new CharacterRange (pieces[i].start, pieces[i].length);

			string_format.SetMeasurableCharacterRanges (ranges);

			Region[] regions = TextRenderer.MeasureCharacterRanges (Text,
										 ThemeEngine.Current.GetLinkFont (this),
										 PaddingClientRectangle,
										 string_format);

			for (int i = 0; i < pieces.Length; i ++) {
				pieces[i].region = regions[i];
				pieces[i].region.Translate (Padding.Left, Padding.Top);
			}

			Invalidate ();
		}

		private void SortLinks ()
		{
			if (sorted_links != null)
				return;

			sorted_links = new Link [Links.Count];
			((ICollection)Links).CopyTo (sorted_links, 0);

			Array.Sort (sorted_links, new LinkComparer ());
		}

		/* Check if the links overlap */
		private void CheckLinks ()
		{
			SortLinks ();

			int current_end = 0;

			for (int i = 0; i < sorted_links.Length; i++) {
				if (sorted_links[i].Start < current_end)
					throw new InvalidOperationException ("Overlapping link regions.");
				current_end = sorted_links[i].Start + sorted_links[i].Length;
			}
		}
		
		#endregion // Private Methods

		//
		// System.Windows.Forms.LinkLabel.Link
		//
		[TypeConverter (typeof (LinkConverter))]
		public class Link
		{
			private bool enabled;
			internal int length;
			private object linkData;
			private int start;
			private bool visited;
			private LinkLabel owner;
			private bool hovered;
			internal ArrayList pieces;
			private bool focused;
			private bool active;
			private string description;
			private string name;
			private object tag;

			internal Link (LinkLabel owner)
			{
				focused = false;
				enabled = true;
				visited = false;
				length = start = 0;
				linkData = null;
				this.owner = owner;
				pieces = new ArrayList ();
				name = string.Empty;
			}

			public Link ()
			{
				this.enabled = true;
				this.name = string.Empty;
				this.pieces = new ArrayList ();
			}

			public Link (int start, int length) : this ()
			{
				this.start = start;
				this.length = length;
			}

			public Link (int start, int length, Object linkData) : this (start, length)
			{
				this.linkData = linkData;
			}

			#region Public Properties
			public string Description {
				get { return this.description; }
				set { this.description = value; }
			}
			
			[DefaultValue ("")]
			public string Name {
				get { return this.name; }
				set { this.name = value; }
			}
			
			[Bindable (true)]
			[Localizable (false)]
			[DefaultValue (null)]
			[TypeConverter (typeof (StringConverter))]
			public Object Tag {
				get { return this.tag; }
				set { this.tag = value; }
			}
				
			[DefaultValue (true)]
			public bool Enabled {
				get { return enabled; }
				set {
					if (enabled != value)
						Invalidate ();

					enabled = value;
				}
			}

			public int Length {
				get { 
					if (length == -1) {
						return owner.Text.Length;
					}
					
					return length; 
				}
				set {
					if (length == value)
						return;
					
					length = value;

					owner.CreateLinkPieces ();
				}
			}

			[DefaultValue (null)]
			public object LinkData {
				get { return linkData; }
				set { linkData = value; }
			}

			public int Start {
				get { return start; }
				set {
					if (start == value)
						return;

					start = value;

					owner.sorted_links = null;
					owner.CreateLinkPieces ();
				}
			}

			[DefaultValue (false)]
			public bool Visited {
				get { return visited; }
				set {
					if (visited != value)
						Invalidate ();

					visited = value;
				}
			}
			
			internal bool Hovered {
				get { return hovered; }
				set {
					if (hovered != value)
						Invalidate ();
					hovered = value;
				}
			}

			internal bool Focused {
				get { return focused; }
				set {
					if (focused != value)
						Invalidate ();
					focused = value;
				}
			}

			internal bool Active {
				get { return active; }
				set {
					if (active != value)
						Invalidate ();
					active = value;
				}
			}

			internal LinkLabel Owner {
				set { owner = value; }
			}
			#endregion

			private void Invalidate ()
			{
				for (int i = 0; i < pieces.Count; i ++)
					owner.Invalidate (((Piece)pieces[i]).region);
			}

			internal bool Contains (int x, int y)
			{
				foreach (Piece p in pieces) {
					if (p.region.IsVisible (new Point (x,y)))
						return true;
				}
				return false;
			}
		}

		class LinkComparer : IComparer
		{
			public int Compare (object x, object y)
			{
				Link l1 = (Link)x;
				Link l2 = (Link)y;

				return l1.Start - l2.Start;
			}
		}

		//
		// System.Windows.Forms.LinkLabel.LinkCollection
		//
		public class LinkCollection :  IList, ICollection, IEnumerable
		{
			private LinkLabel owner;
			private bool links_added;

			public LinkCollection (LinkLabel owner)
			{
				if (owner == null)
					throw new ArgumentNullException ("owner");

				this.owner = owner;
			}

			[Browsable (false)]
			public int Count {
				get { return owner.links.Count; }
			}

			public bool IsReadOnly {
				get { return false; }
			}

			public virtual LinkLabel.Link this[int index] {
				get {
					if (index < 0 || index >= Count)
						throw  new  ArgumentOutOfRangeException();

					return (LinkLabel.Link) owner.links[index];
				}
				set {
					if (index < 0 || index >= Count)
						throw new  ArgumentOutOfRangeException();

					owner.links[index] = value;
				}
			}

			public virtual Link this[string key] {
				get {
					if (string.IsNullOrEmpty (key))
						return null;
						
					foreach (Link l in owner.links)
						if (string.Compare (l.Name, key, true) == 0)
							return l;
							
					return null;
				}
			}
			
			public int Add (Link value)
			{
				value.Owner = owner;
				/* remove the default 0,-1 link */
				if (IsDefault) {
					/* don't call Clear() here to save the additional CreateLinkPieces */
					owner.links.Clear ();
				}

				int idx = owner.links.Add (value);
				links_added = true;

				owner.sorted_links = null;
				owner.CheckLinks ();
				owner.CreateLinkPieces ();

				return idx;
			}

			public Link Add (int start, int length)
			{
				return Add (start, length, null);
			}
			
			internal bool IsDefault {
				get {
					return (Count == 1
						&& this[0].Start == 0
						&& this[0].length == -1);
				}
			}

			public Link Add (int start, int length, object linkData)
			{
				Link link = new Link (owner);
				link.Length = length;
				link.Start = start;
				link.LinkData = linkData;

				int idx = Add (link);

				return (Link) owner.links[idx];
			}

			public virtual void Clear ()
			{
				owner.links.Clear();
				owner.sorted_links = null;
				owner.CreateLinkPieces ();
			}

			public bool Contains (Link link)
			{
				return owner.links.Contains (link);
			}

			public virtual bool ContainsKey (string key)
			{
				return !(this[key] == null);
			}

			public IEnumerator GetEnumerator ()
			{
				return owner.links.GetEnumerator ();
			}

			public int IndexOf (Link link)
			{
				return owner.links.IndexOf (link);
			}

			public virtual int IndexOfKey (string key)
			{
				if (string.IsNullOrEmpty (key))
					return -1;
					
				return IndexOf (this[key]);
			}
			
			public bool LinksAdded {
				get { return this.links_added; }
			}

			public void Remove (LinkLabel.Link value)
			{
				owner.links.Remove (value);
				owner.sorted_links = null;
				owner.CreateLinkPieces ();
			}

			public virtual void RemoveByKey (string key)
			{	
				Remove (this[key]);
			}

			public void RemoveAt (int index)
			{
				if (index >= Count)
					throw new ArgumentOutOfRangeException ("Invalid value for array index");

				owner.links.Remove (owner.links[index]);
				owner.sorted_links = null;
				owner.CreateLinkPieces ();
			}

			bool IList.IsFixedSize {
				get {return false;}
			}

			object IList.this[int index] {
				get { return owner.links[index]; }
				set { owner.links[index] = value; }
			}

			object ICollection.SyncRoot {
				get {return this;}
			}

			bool ICollection.IsSynchronized {
				get {return false;}
			}

			void ICollection.CopyTo (Array dest, int index)
			{
				owner.links.CopyTo (dest, index);
			}

			int IList.Add (object value)
			{
				int idx = owner.links.Add (value);
				owner.sorted_links = null;
				owner.CheckLinks ();
				owner.CreateLinkPieces ();
				return idx;
			}

			bool IList.Contains (object link)
			{
				return Contains ((Link) link);
			}

			int IList.IndexOf (object link)
			{
				return owner.links.IndexOf (link);
			}

			void IList.Insert (int index, object value)
			{
				owner.links.Insert (index, value);
				owner.sorted_links = null;
				owner.CheckLinks ();
				owner.CreateLinkPieces ();
			}

			void IList.Remove (object value)
			{
				Remove ((Link) value);
			}
		}

		[RefreshProperties (RefreshProperties.Repaint)]
		public new bool UseCompatibleTextRendering {
			get {
				return use_compatible_text_rendering;
			}
			set {
				use_compatible_text_rendering = value;
			}
		}
	}
}