diff options
Diffstat (limited to 'source/ShiftUI/Widgets/ListViewItem.cs')
| -rw-r--r-- | source/ShiftUI/Widgets/ListViewItem.cs | 1638 |
1 files changed, 1638 insertions, 0 deletions
diff --git a/source/ShiftUI/Widgets/ListViewItem.cs b/source/ShiftUI/Widgets/ListViewItem.cs new file mode 100644 index 0000000..b9473e1 --- /dev/null +++ b/source/ShiftUI/Widgets/ListViewItem.cs @@ -0,0 +1,1638 @@ +// 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 Novell, Inc. (http://www.novell.com) +// +// Author: +// Ravindra ([email protected]) +// Mike Kestner <[email protected]> +// Daniel Nauck (dna(at)mono-project(dot)de) + +using System.Collections; +using System.ComponentModel; +using System.Drawing; +using System.Runtime.Serialization; +using System; + +namespace ShiftUI +{ + [DefaultProperty ("Text")] + [DesignTimeVisible (false)] + [Serializable] + [ToolboxItem (false)] + [TypeConverter (typeof (ListViewItemConverter))] + public class ListViewItem : ICloneable, ISerializable + { + #region Instance Variables + private int image_index = -1; + private bool is_checked = false; + private int state_image_index = -1; + private ListViewSubItemCollection sub_items; + private object tag; + private bool use_item_style = true; + int display_index = -1; // actual position in ListView + private ListViewGroup group = null; + private string name = String.Empty; + private string image_key = String.Empty; + string tooltip_text = String.Empty; + int indent_count; + Point position = new Point (-1, -1); // cached to mimic .Net behaviour + Rectangle bounds = Rectangle.Empty; + Rectangle checkbox_rect; // calculated by CalcListViewItem method + Rectangle icon_rect; + Rectangle item_rect; + Rectangle label_rect; + ListView owner; + Font font; + Font hot_font; // cached font for hot tracking + bool selected; + + internal int row; + internal int col; + + + #region UIA Framework: Methods, Properties and Events + + internal event EventHandler UIATextChanged; + + internal event LabelEditEventHandler UIASubItemTextChanged; + + internal void OnUIATextChanged () + { + if (UIATextChanged != null) + UIATextChanged (this, EventArgs.Empty); + } + + internal void OnUIASubItemTextChanged (LabelEditEventArgs args) + { + //If our index is 0 we also generate TextChanged for the ListViewItem + //because ListViewItem.Text is the same as ListViewItem.SubItems [0].Text + if (args.Item == 0) + OnUIATextChanged (); + + if (UIASubItemTextChanged != null) + UIASubItemTextChanged (this, args); + } + + #endregion // UIA Framework: Methods, Properties and Events + + + #endregion Instance Variables + + #region Public Constructors + public ListViewItem () : this (string.Empty) + { + } + + public ListViewItem (string text) : this (text, -1) + { + } + + public ListViewItem (string [] items) : this (items, -1) + { + } + + public ListViewItem (ListViewItem.ListViewSubItem [] subItems, int imageIndex) + { + this.sub_items = new ListViewSubItemCollection (this, null); + for (int i = 0; i < subItems.Length; i++) + sub_items.Add (subItems [i]); + this.image_index = imageIndex; + } + + public ListViewItem (string text, int imageIndex) + { + this.image_index = imageIndex; + this.sub_items = new ListViewSubItemCollection (this, text); + } + + public ListViewItem (string [] items, int imageIndex) + { + this.sub_items = new ListViewSubItemCollection (this, null); + if (items != null) { + for (int i = 0; i < items.Length; i++) + sub_items.Add (new ListViewSubItem (this, items [i])); + } + this.image_index = imageIndex; + } + + public ListViewItem (string [] items, int imageIndex, Color foreColor, + Color backColor, Font font) : this (items, imageIndex) + { + ForeColor = foreColor; + BackColor = backColor; + this.font = font; + } + + public ListViewItem(string[] items, string imageKey) : this(items) + { + this.ImageKey = imageKey; + } + + public ListViewItem(string text, string imageKey) : this(text) + { + this.ImageKey = imageKey; + } + + public ListViewItem(ListViewSubItem[] subItems, string imageKey) + { + this.sub_items = new ListViewSubItemCollection (this, null); + for (int i = 0; i < subItems.Length; i++) + this.sub_items.Add (subItems [i]); + this.ImageKey = imageKey; + } + + public ListViewItem(string[] items, string imageKey, Color foreColor, + Color backColor, Font font) : this(items, imageKey) + { + ForeColor = foreColor; + BackColor = backColor; + this.font = font; + } + + public ListViewItem(ListViewGroup group) : this() + { + Group = group; + } + + public ListViewItem(string text, ListViewGroup group) : this(text) + { + Group = group; + } + + public ListViewItem(string[] items, ListViewGroup group) : this(items) + { + Group = group; + } + + public ListViewItem(ListViewSubItem[] subItems, int imageIndex, ListViewGroup group) + : this(subItems, imageIndex) + { + Group = group; + } + + public ListViewItem(ListViewSubItem[] subItems, string imageKey, ListViewGroup group) + : this(subItems, imageKey) + { + Group = group; + } + + public ListViewItem(string text, int imageIndex, ListViewGroup group) + : this(text, imageIndex) + { + Group = group; + } + + public ListViewItem(string text, string imageKey, ListViewGroup group) + : this(text, imageKey) + { + Group = group; + } + + public ListViewItem(string[] items, int imageIndex, ListViewGroup group) + : this(items, imageIndex) + { + Group = group; + } + + public ListViewItem(string[] items, string imageKey, ListViewGroup group) + : this(items, imageKey) + { + Group = group; + } + + public ListViewItem(string[] items, int imageIndex, Color foreColor, Color backColor, + Font font, ListViewGroup group) + : this(items, imageIndex, foreColor, backColor, font) + { + Group = group; + } + + public ListViewItem(string[] items, string imageKey, Color foreColor, Color backColor, + Font font, ListViewGroup group) + : this(items, imageKey, foreColor, backColor, font) + { + Group = group; + } + #endregion // Public Constructors + + protected ListViewItem (SerializationInfo info, StreamingContext context) + { + Deserialize (info, context); + } + + #region Public Instance Properties + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)] + public Color BackColor { + get { + if (sub_items.Count > 0) + return sub_items[0].BackColor; + + if (owner != null) + return owner.BackColor; + + return ThemeEngine.Current.ColorWindow; + } + set { SubItems [0].BackColor = value; } + } + + [Browsable (false)] + public Rectangle Bounds { + get { + return GetBounds (ItemBoundsPortion.Entire); + } + } + + [DefaultValue (false)] + [RefreshProperties (RefreshProperties.Repaint)] + public bool Checked { + get { return is_checked; } + set { + if (is_checked == value) + return; + + if (owner != null) { + CheckState current_value = is_checked ? CheckState.Checked : CheckState.Unchecked; + CheckState new_value = value ? CheckState.Checked : CheckState.Unchecked; + + ItemCheckEventArgs icea = new ItemCheckEventArgs (Index, + new_value, current_value); + owner.OnItemCheck (icea); + + if (new_value != current_value) { + // force re-population of list + owner.CheckedItems.Reset (); + is_checked = new_value == CheckState.Checked; + Invalidate (); + + ItemCheckedEventArgs args = new ItemCheckedEventArgs (this); + owner.OnItemChecked (args); + } + } else + is_checked = value; + } + } + + [Browsable (false)] + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)] + public bool Focused { + get { + if (owner == null) + return false; + + // In virtual mode the checks are always done using indexes + if (owner.VirtualMode) + return Index == owner.focused_item_index; + + // Light check + return owner.FocusedItem == this; + + } + set { + if (owner == null) + return; + + if (Focused == value) + return; + + ListViewItem prev_focused_item = owner.FocusedItem; + if (prev_focused_item != null) + prev_focused_item.UpdateFocusedState (); + + owner.focused_item_index = value ? Index : -1; + if (value) + owner.OnUIAFocusedItemChanged (); + + UpdateFocusedState (); + } + } + + [Localizable (true)] + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)] + public Font Font { + get { + if (font != null) + return font; + else if (owner != null) + return owner.Font; + + return ThemeEngine.Current.DefaultFont; + } + set { + if (font == value) + return; + + font = value; + hot_font = null; + + if (owner != null) + Layout (); + Invalidate (); + } + } + + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)] + public Color ForeColor { + get { + if (sub_items.Count > 0) + return sub_items[0].ForeColor; + + if (owner != null) + return owner.ForeColor; + + return ThemeEngine.Current.ColorWindowText; + } + set { SubItems [0].ForeColor = value; } + } + + [DefaultValue (-1)] + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)] + //[Editor ("ShiftUI.Design.ImageIndexEditor, " + Consts.AssemblySystem_Design, + //typeof (System.Drawing.Design.UITypeEditor))] + [Localizable (true)] + [RefreshProperties (RefreshProperties.Repaint)] + [TypeConverter (typeof (NoneExcludedImageIndexConverter))] + public int ImageIndex { + get { return image_index; } + set { + if (value < -1) + throw new ArgumentException ("Invalid ImageIndex. It must be greater than or equal to -1."); + + image_index = value; + image_key = String.Empty; + + if (owner != null) + Layout (); + Invalidate (); + } + } + + [DefaultValue ("")] + [LocalizableAttribute (true)] + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)] + //[Editor ("ShiftUI.Design.ImageIndexEditor, " + Consts.AssemblySystem_Design, + //typeof (System.Drawing.Design.UITypeEditor))] + [RefreshProperties (RefreshProperties.Repaint)] + [TypeConverter (typeof (ImageKeyConverter))] + public string ImageKey { + get { + return image_key; + } + set { + image_key = value == null ? String.Empty : value; + image_index = -1; + + if (owner != null) + Layout (); + Invalidate (); + } + } + + [Browsable (false)] + public ImageList ImageList { + get { + if (owner == null) + return null; + else if (owner.View == View.LargeIcon) + return owner.large_image_list; + else + return owner.small_image_list; + } + } + + [DefaultValue (0)] + public int IndentCount { + get { + return indent_count; + } + set { + if (value < 0) + throw new ArgumentOutOfRangeException ("value"); + + if (value == indent_count) + return; + + indent_count = value; + Invalidate (); + } + } + + [Browsable (false)] + public int Index { + get { + if (owner == null) + return -1; + if (owner.VirtualMode) + return display_index; + + if (display_index == -1) + return owner.Items.IndexOf (this); + + return owner.GetItemIndex (display_index); + } + } + + [Browsable (false)] + public ListView ListView { + get { return owner; } + } + + [Browsable (false)] + [Localizable (true)] + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)] + public string Name { + get { + return name; + } + set { + name = value == null ? String.Empty : value; + } + } + + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)] + [Browsable (false)] + public Point Position { + get { + if (owner != null && owner.VirtualMode) + return owner.GetItemLocation (display_index); + + if (owner != null && !owner.IsHandleCreated) + return new Point (-1, -1); + + return position; + } + set { + if (owner == null || owner.View == View.Details || owner.View == View.List) + return; + + if (owner.VirtualMode) + throw new InvalidOperationException (); + + owner.ChangeItemLocation (display_index, value); + } + } + + // When ListView uses VirtualMode, selection state info + // lives in the ListView, not in the item + // Also, in VirtualMode we can't Reset() the selection + [Browsable (false)] + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)] + public bool Selected { + get { + if (owner != null && owner.VirtualMode) + return owner.SelectedIndices.Contains (Index); + + return selected; + } + set { + if (selected == value && owner != null && !owner.VirtualMode) + return; + + SetSelectedCore (value); + } + } + + // Expose this method as internal so we can force an update in the selection. + internal void SetSelectedCore (bool value) + { + if (owner != null) { + if (value && !owner.MultiSelect) + owner.SelectedIndices.Clear (); + if (owner.VirtualMode) { + if (value) + owner.SelectedIndices.InsertIndex (Index); + else + owner.SelectedIndices.RemoveIndex (Index); + } else { + selected = value; + owner.SelectedIndices.Reset (); // force re-population of list + } + + owner.OnItemSelectionChanged (new ListViewItemSelectionChangedEventArgs (this, Index, value)); + owner.OnSelectedIndexChanged (); + Invalidate (); + } else + selected = value; + } + + [DefaultValue (-1)] + //[Editor ("ShiftUI.Design.ImageIndexEditor, " + Consts.AssemblySystem_Design, + //typeof (System.Drawing.Design.UITypeEditor))] + [Localizable (true)] + [RefreshProperties (RefreshProperties.Repaint)] + [RelatedImageListAttribute ("ListView.StateImageList")] + [TypeConverter (typeof (NoneExcludedImageIndexConverter))] + public int StateImageIndex { + get { return state_image_index; } + set { + if (value < -1 || value > 14) + throw new ArgumentOutOfRangeException ("Invalid StateImageIndex. It must be in the range of [-1, 14]."); + + state_image_index = value; + } + } + + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)] + //[Editor ("ShiftUI.Design.ListViewSubItemCollectionEditor, " + Consts.AssemblySystem_Design, + //typeof (System.Drawing.Design.UITypeEditor))] + public ListViewSubItemCollection SubItems { + get { + if (sub_items.Count == 0) + this.sub_items.Add (string.Empty); + return sub_items; + } + } + + [Bindable (true)] + [DefaultValue (null)] + [Localizable (false)] + [TypeConverter (typeof (StringConverter))] + public object Tag { + get { return tag; } + set { tag = value; } + } + + [Localizable (true)] + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)] + public string Text { + get { + if (this.sub_items.Count > 0) + return this.sub_items [0].Text; + else + return string.Empty; + } + set { + if (SubItems [0].Text == value) + return; + + sub_items [0].Text = value; + + if (owner != null) + Layout (); + Invalidate (); + + //UIA Framework: Generates Text changed + OnUIATextChanged (); + + } + } + + [DefaultValue (true)] + public bool UseItemStyleForSubItems { + get { return use_item_style; } + set { use_item_style = value; } + } + + [LocalizableAttribute(true)] + [DefaultValue (null)] + public ListViewGroup Group { + get { return this.group; } + set { + if (group != value) { + if (value == null) + group.Items.Remove (this); + else + value.Items.Add (this); + + group = value; + } + } + } + + [DefaultValue ("")] + public string ToolTipText { + get { + return tooltip_text; + } + set { + if (value == null) + value = String.Empty; + + tooltip_text = value; + } + } + + #endregion // Public Instance Properties + + #region Public Instance Methods + public void BeginEdit () + { + if (owner != null && owner.LabelEdit) { + owner.item_control.BeginEdit (this); + } + // FIXME: TODO + // if (owner != null && owner.LabelEdit + // && owner.Activation == ItemActivation.Standard) + // allow editing + // else + // throw new InvalidOperationException (); + } + + public virtual object Clone () + { + ListViewItem clone = new ListViewItem (); + clone.image_index = this.image_index; + clone.is_checked = this.is_checked; + clone.selected = this.selected; + clone.font = this.font; + clone.state_image_index = this.state_image_index; + clone.sub_items = new ListViewSubItemCollection (this, null); + + foreach (ListViewSubItem subItem in this.sub_items) + clone.sub_items.Add (subItem.Text, subItem.ForeColor, + subItem.BackColor, subItem.Font); + clone.tag = this.tag; + clone.use_item_style = this.use_item_style; + clone.owner = null; + clone.name = name; + clone.tooltip_text = tooltip_text; + + return clone; + } + + public virtual void EnsureVisible () + { + if (this.owner != null) { + owner.EnsureVisible (owner.Items.IndexOf (this)); + } + } + + public ListViewItem FindNearestItem (SearchDirectionHint searchDirection) + { + if (owner == null) + return null; + + Point loc = owner.GetItemLocation (display_index); + return owner.FindNearestItem (searchDirection, loc); + } + + public Rectangle GetBounds (ItemBoundsPortion portion) + { + if (owner == null) + return Rectangle.Empty; + + Rectangle rect; + + switch (portion) { + case ItemBoundsPortion.Icon: + rect = icon_rect; + break; + + case ItemBoundsPortion.Label: + rect = label_rect; + break; + + case ItemBoundsPortion.ItemOnly: + rect = item_rect; + break; + + case ItemBoundsPortion.Entire: + rect = bounds; + break; + + default: + throw new ArgumentException ("Invalid value for portion."); + } + + Point item_loc = owner.GetItemLocation (DisplayIndex); + rect.X += item_loc.X; + rect.Y += item_loc.Y; + return rect; + } + + void ISerializable.GetObjectData (SerializationInfo info, StreamingContext context) + { + Serialize (info, context); + } + + public ListViewSubItem GetSubItemAt (int x, int y) + { + if (owner != null && owner.View != View.Details) + return null; + + foreach (ListViewSubItem sub_item in sub_items) + if (sub_item.Bounds.Contains (x, y)) + return sub_item; + + return null; + } + + public virtual void Remove () + { + if (owner == null) + return; + + owner.item_control.CancelEdit (this); + owner.Items.Remove (this); + owner = null; + } + + public override string ToString () + { + return string.Format ("ListViewItem: {0}", this.Text); + } + #endregion // Public Instance Methods + + #region Protected Methods + protected virtual void Deserialize (SerializationInfo info, StreamingContext context) + { + sub_items = new ListViewSubItemCollection (this, null); + int sub_items_count = 0; + + foreach (SerializationEntry entry in info) { + switch (entry.Name) { + case "Text": + sub_items.Add ((string)entry.Value); + break; + case "Font": + font = (Font)entry.Value; + break; + case "Checked": + is_checked = (bool)entry.Value; + break; + case "ImageIndex": + image_index = (int)entry.Value; + break; + case "StateImageIndex": + state_image_index = (int)entry.Value; + break; + case "UseItemStyleForSubItems": + use_item_style = (bool)entry.Value; + break; + case "SubItemCount": + sub_items_count = (int)entry.Value; + break; + case "Group": + group = (ListViewGroup)entry.Value; + break; + case "ImageKey": + if (image_index == -1) + image_key = (string)entry.Value; + break; + } + } + + Type subitem_type = typeof (ListViewSubItem); + if (sub_items_count > 0) { + sub_items.Clear (); // .net fixup + Text = info.GetString ("Text"); + for (int i = 0; i < sub_items_count - 1; i++) + sub_items.Add ((ListViewSubItem)info.GetValue ("SubItem" + (i + 1), subitem_type)); + } + + // After any sub item has been added. + ForeColor = (Color)info.GetValue ("ForeColor", typeof (Color)); + BackColor = (Color)info.GetValue ("BackColor", typeof (Color)); + } + + protected virtual void Serialize (SerializationInfo info, StreamingContext context) + { + info.AddValue ("Text", Text); + info.AddValue ("Font", Font); + info.AddValue ("ImageIndex", image_index); + info.AddValue ("Checked", is_checked); + info.AddValue ("StateImageIndex", state_image_index); + info.AddValue ("UseItemStyleForSubItems", use_item_style); + info.AddValue ("BackColor", BackColor); + info.AddValue ("ForeColor", ForeColor); + info.AddValue ("ImageKey", image_key); + if (group != null) + info.AddValue ("Group", group); + if (sub_items.Count > 1) { + info.AddValue ("SubItemCount", sub_items.Count); + for (int i = 1; i < sub_items.Count; i++) { + info.AddValue ("SubItem" + i, sub_items [i]); + } + } + } + #endregion // Protected Methods + + #region Private Internal Methods + internal Rectangle CheckRectReal { + get { + Rectangle rect = checkbox_rect; + Point item_loc = owner.GetItemLocation (DisplayIndex); + rect.X += item_loc.X; + rect.Y += item_loc.Y; + return rect; + } + } + + Rectangle text_bounds; + internal Rectangle TextBounds { + get { + // Call Layout() if it hasn't been called before. + if (owner.VirtualMode && bounds == new Rectangle (-1, -1, -1, -1)) + Layout (); + Rectangle result = text_bounds; + Point loc = owner.GetItemLocation (DisplayIndex); + result.X += loc.X; + result.Y += loc.Y; + return result; + } + } + + internal int DisplayIndex { + get { + // Special case for Details view + // and no columns (which means no Layout at all) + if (display_index == -1) + return owner.Items.IndexOf (this); + + return display_index; + } + set { + display_index = value; + } + } + + internal bool Hot { + get { + return Index == owner.HotItemIndex; + } + } + + internal Font HotFont { + get { + if (hot_font == null) + hot_font = new Font (Font, Font.Style | FontStyle.Underline); + + return hot_font; + } + } + + internal ListView Owner { + set { + if (owner == value) + return; + + owner = value; + } + } + + internal void SetGroup (ListViewGroup group) + { + this.group = group; + } + + internal void SetPosition (Point position) + { + this.position = position; + } + + // When focus changed, we need to invalidate area + // with previous layout and with the new one + void UpdateFocusedState () + { + if (owner != null) { + Invalidate (); + Layout (); + Invalidate (); + } + } + + internal void Invalidate () + { + if (owner == null || owner.item_control == null || owner.updating) + return; + + // Add some padding to bounds (focused extra space, selection) + Rectangle rect = Bounds; + rect.Inflate (1, 1); + owner.item_control.Invalidate (rect); + } + + internal void Layout () + { + if (owner == null) + return; + int item_ht; + Rectangle total; + Size text_size = owner.text_size; + + checkbox_rect = Rectangle.Empty; + if (owner.CheckBoxes) + checkbox_rect.Size = owner.CheckBoxSize; + switch (owner.View) { + case View.Details: + // LAMESPEC: MSDN says, "In all views except the details + // view of the ListView, this value specifies the same + // bounding rectangle as the Entire value." Actually, it + // returns same bounding rectangles for Item and Entire + // values in the case of Details view. + + int x_offset = 0; + if (owner.SmallImageList != null) + x_offset = indent_count * owner.SmallImageList.ImageSize.Width; + + // Handle reordered column + if (owner.Columns.Count > 0) + checkbox_rect.X = owner.Columns[0].Rect.X + x_offset; + + icon_rect = label_rect = Rectangle.Empty; + icon_rect.X = checkbox_rect.Right + 2; + item_ht = owner.ItemSize.Height; + + if (owner.SmallImageList != null) + icon_rect.Width = owner.SmallImageList.ImageSize.Width; + + label_rect.Height = icon_rect.Height = item_ht; + checkbox_rect.Y = item_ht - checkbox_rect.Height; + + label_rect.X = icon_rect.Width > 0 ? icon_rect.Right + 1 : icon_rect.Right; + + if (owner.Columns.Count > 0) + label_rect.Width = owner.Columns[0].Wd - label_rect.X + checkbox_rect.X; + else + label_rect.Width = text_size.Width; + + SizeF text_sz = TextRenderer.MeasureString (Text, Font); + text_bounds = label_rect; + text_bounds.Width = (int) text_sz.Width; + + item_rect = total = Rectangle.Union + (Rectangle.Union (checkbox_rect, icon_rect), label_rect); + bounds.Size = total.Size; + + item_rect.Width = 0; + bounds.Width = 0; + for (int i = 0; i < owner.Columns.Count; i++) { + item_rect.Width += owner.Columns [i].Wd; + bounds.Width += owner.Columns [i].Wd; + } + + // Bounds for sub items + int n = Math.Min (owner.Columns.Count, sub_items.Count); + for (int i = 0; i < n; i++) { + Rectangle col_rect = owner.Columns [i].Rect; + sub_items [i].SetBounds (col_rect.X, 0, col_rect.Width, item_ht); + } + break; + + case View.LargeIcon: + label_rect = icon_rect = Rectangle.Empty; + + SizeF sz = TextRenderer.MeasureString (Text, Font); + if ((int) sz.Width > text_size.Width) { + if (Focused && owner.InternalContainsFocus) { + int text_width = text_size.Width; + StringFormat format = new StringFormat (); + format.Alignment = StringAlignment.Center; + sz = TextRenderer.MeasureString (Text, Font, text_width, format); + text_size.Height = (int) sz.Height; + } else + text_size.Height = 2 * (int) sz.Height; + } + + if (owner.LargeImageList != null) { + icon_rect.Width = owner.LargeImageList.ImageSize.Width; + icon_rect.Height = owner.LargeImageList.ImageSize.Height; + } + + if (checkbox_rect.Height > icon_rect.Height) + icon_rect.Y = checkbox_rect.Height - icon_rect.Height; + else + checkbox_rect.Y = icon_rect.Height - checkbox_rect.Height; + + if (text_size.Width <= icon_rect.Width) { + icon_rect.X = checkbox_rect.Width + 1; + label_rect.X = icon_rect.X + (icon_rect.Width - text_size.Width) / 2; + label_rect.Y = icon_rect.Bottom + 2; + label_rect.Size = text_size; + } else { + int centerX = text_size.Width / 2; + icon_rect.X = checkbox_rect.Width + 1 + centerX - icon_rect.Width / 2; + label_rect.X = checkbox_rect.Width + 1; + label_rect.Y = icon_rect.Bottom + 2; + label_rect.Size = text_size; + } + + item_rect = Rectangle.Union (icon_rect, label_rect); + total = Rectangle.Union (item_rect, checkbox_rect); + bounds.Size = total.Size; + break; + + case View.List: + case View.SmallIcon: + label_rect = icon_rect = Rectangle.Empty; + icon_rect.X = checkbox_rect.Width + 1; + item_ht = Math.Max (owner.CheckBoxSize.Height, text_size.Height); + + if (owner.SmallImageList != null) { + item_ht = Math.Max (item_ht, owner.SmallImageList.ImageSize.Height); + icon_rect.Width = owner.SmallImageList.ImageSize.Width; + icon_rect.Height = owner.SmallImageList.ImageSize.Height; + } + + checkbox_rect.Y = item_ht - checkbox_rect.Height; + label_rect.X = icon_rect.Right + 1; + label_rect.Width = text_size.Width; + label_rect.Height = icon_rect.Height = item_ht; + + item_rect = Rectangle.Union (icon_rect, label_rect); + total = Rectangle.Union (item_rect, checkbox_rect); + bounds.Size = total.Size; + break; + case View.Tile: + if (!Application.VisualStylesEnabled) + goto case View.LargeIcon; + + label_rect = icon_rect = Rectangle.Empty; + + if (owner.LargeImageList != null) { + icon_rect.Width = owner.LargeImageList.ImageSize.Width; + icon_rect.Height = owner.LargeImageList.ImageSize.Height; + } + + int separation = 2; + SizeF tsize = TextRenderer.MeasureString (Text, Font); + int main_item_height = (int) Math.Ceiling (tsize.Height); + int main_item_width = (int) Math.Ceiling (tsize.Width); + sub_items [0].bounds.Height = main_item_height; + + // Set initial values for subitem's layout + int total_height = main_item_height; + int max_subitem_width = main_item_width; + + int count = Math.Min (owner.Columns.Count, sub_items.Count); + for (int i = 1; i < count; i++) { // Ignore first column and first subitem + ListViewSubItem sub_item = sub_items [i]; + if (sub_item.Text == null || sub_item.Text.Length == 0) + continue; + + tsize = TextRenderer.MeasureString (sub_item.Text, sub_item.Font); + + int width = (int)Math.Ceiling (tsize.Width); + if (width > max_subitem_width) + max_subitem_width = width; + + int height = (int)Math.Ceiling (tsize.Height); + total_height += height + separation; + + sub_item.bounds.Height = height; + } + + max_subitem_width = Math.Min (max_subitem_width, owner.TileSize.Width - (icon_rect.Width + 4)); + label_rect.X = icon_rect.Right + 4; + label_rect.Y = owner.TileSize.Height / 2 - total_height / 2; + label_rect.Width = max_subitem_width; + label_rect.Height = total_height; + + // Main item - always set bounds for it + sub_items [0].SetBounds (label_rect.X, label_rect.Y, max_subitem_width, sub_items [0].bounds.Height); + + // Second pass to assign bounds for every sub item + int current_y = sub_items [0].bounds.Bottom + separation; + for (int j = 1; j < count; j++) { + ListViewSubItem sub_item = sub_items [j]; + if (sub_item.Text == null || sub_item.Text.Length == 0) + continue; + + sub_item.SetBounds (label_rect.X, current_y, max_subitem_width, sub_item.bounds.Height); + current_y += sub_item.Bounds.Height + separation; + } + + item_rect = Rectangle.Union (icon_rect, label_rect); + bounds.Size = item_rect.Size; + break; + } + + } + #endregion // Private Internal Methods + + #region Subclasses + + [DefaultProperty ("Text")] + [DesignTimeVisible (false)] + [Serializable] + [ToolboxItem (false)] + [TypeConverter (typeof(ListViewSubItemConverter))] + public class ListViewSubItem + { + [NonSerialized] + internal ListViewItem owner; + private string text = string.Empty; + private string name; + private object userData; + private SubItemStyle style; + [NonSerialized] + internal Rectangle bounds; + + + #region UIA Framework: Methods, Properties and Events + + [field:NonSerialized] + internal event EventHandler UIATextChanged; + + private void OnUIATextChanged () + { + if (UIATextChanged != null) + UIATextChanged (this, EventArgs.Empty); + } + + #endregion // UIA Framework: Methods, Properties and Events + + + #region Public Constructors + public ListViewSubItem () + : this (null, string.Empty, Color.Empty, + Color.Empty, null) + { + } + + public ListViewSubItem (ListViewItem owner, string text) + : this (owner, text, Color.Empty, + Color.Empty, null) + { + } + + public ListViewSubItem (ListViewItem owner, string text, Color foreColor, + Color backColor, Font font) + { + this.owner = owner; + Text = text; + this.style = new SubItemStyle (foreColor, + backColor, font); + } + #endregion // Public Constructors + + #region Public Instance Properties + public Color BackColor { + get { + if (style.backColor != Color.Empty) + return style.backColor; + if (this.owner != null && this.owner.ListView != null) + return this.owner.ListView.BackColor; + return ThemeEngine.Current.ColorWindow; + } + set { + style.backColor = value; + Invalidate (); + } + } + + [Browsable (false)] + public Rectangle Bounds { + get { + Rectangle retval = bounds; + if (owner != null) { + retval.X += owner.Bounds.X; + retval.Y += owner.Bounds.Y; + } + + return retval; + } + } + + [Localizable (true)] + public Font Font { + get { + if (style.font != null) + return style.font; + else if (owner != null) + return owner.Font; + return ThemeEngine.Current.DefaultFont; + } + set { + if (style.font == value) + return; + style.font = value; + Invalidate (); + } + } + + public Color ForeColor { + get { + if (style.foreColor != Color.Empty) + return style.foreColor; + if (this.owner != null && this.owner.ListView != null) + return this.owner.ListView.ForeColor; + return ThemeEngine.Current.ColorWindowText; + } + set { + style.foreColor = value; + Invalidate (); + } + } + + [Localizable (true)] + public string Name { + get { + if (name == null) + return string.Empty; + return name; + } + set { + name = value; + } + } + + [TypeConverter (typeof (StringConverter))] + [BindableAttribute (true)] + [DefaultValue (null)] + [Localizable (false)] + public object Tag { + get { + return userData; + } + set { + userData = value; + } + } + + [Localizable (true)] + public string Text { + get { return text; } + set { + if(text == value) + return; + + if(value == null) + text = string.Empty; + else + text = value; + + Invalidate (); + + // UIA Framework: Generates SubItem TextChanged + OnUIATextChanged (); + } + } + #endregion // Public Instance Properties + + #region Public Methods + public void ResetStyle () + { + style.Reset (); + Invalidate (); + } + + public override string ToString () + { + return string.Format ("ListViewSubItem {{0}}", text); + } + #endregion // Public Methods + + #region Private Methods + private void Invalidate () + { + if (owner == null || owner.owner == null) + return; + + owner.Invalidate (); + } + + [OnDeserialized] + void OnDeserialized (StreamingContext context) + { + name = null; + userData = null; + } + + internal int Height { + get { + return bounds.Height; + } + } + + internal void SetBounds (int x, int y, int width, int height) + { + bounds = new Rectangle (x, y, width, height); + } + + #endregion // Private Methods + + [Serializable] + class SubItemStyle + { + public SubItemStyle () + { + } + + public SubItemStyle (Color foreColor, Color backColor, Font font) + { + this.foreColor = foreColor; + this.backColor = backColor; + this.font = font; + } + + public void Reset () + { + foreColor = Color.Empty; + backColor = Color.Empty; + font = null; + } + + public Color backColor; + public Color foreColor; + public Font font; + } + } + + public class ListViewSubItemCollection : IList, ICollection, IEnumerable + { + private ArrayList list; + internal ListViewItem owner; + + #region Public Constructors + public ListViewSubItemCollection (ListViewItem owner) : this (owner, owner.Text) + { + } + #endregion // Public Constructors + + internal ListViewSubItemCollection (ListViewItem owner, string text) + { + this.owner = owner; + this.list = new ArrayList (); + if (text != null) + Add (text); + } + #region Public Properties + [Browsable (false)] + public int Count { + get { return list.Count; } + } + + public bool IsReadOnly { + get { return false; } + } + + public ListViewSubItem this [int index] { + get { return (ListViewSubItem) list [index]; } + set { + value.owner = owner; + list [index] = value; + owner.Layout (); + owner.Invalidate (); + } + } + + public virtual ListViewSubItem this [string key] { + get { + int idx = IndexOfKey (key); + if (idx == -1) + return null; + + return (ListViewSubItem) list [idx]; + } + } + + bool ICollection.IsSynchronized { + get { return list.IsSynchronized; } + } + + object ICollection.SyncRoot { + get { return list.SyncRoot; } + } + + bool IList.IsFixedSize { + get { return list.IsFixedSize; } + } + + object IList.this [int index] { + get { return this [index]; } + set { + if (! (value is ListViewSubItem)) + throw new ArgumentException ("Not of type ListViewSubItem", "value"); + this [index] = (ListViewSubItem) value; + } + } + #endregion // Public Properties + + #region Public Methods + public ListViewSubItem Add (ListViewSubItem item) + { + AddSubItem (item); + owner.Layout (); + owner.Invalidate (); + return item; + } + + public ListViewSubItem Add (string text) + { + ListViewSubItem item = new ListViewSubItem (owner, text); + return Add (item); + } + + public ListViewSubItem Add (string text, Color foreColor, + Color backColor, Font font) + { + ListViewSubItem item = new ListViewSubItem (owner, text, + foreColor, backColor, font); + return Add (item); + } + + public void AddRange (ListViewSubItem [] items) + { + if (items == null) + throw new ArgumentNullException ("items"); + + foreach (ListViewSubItem item in items) { + if (item == null) + continue; + AddSubItem (item); + } + owner.Layout (); + owner.Invalidate (); + } + + public void AddRange (string [] items) + { + if (items == null) + throw new ArgumentNullException ("items"); + + foreach (string item in items) { + if (item == null) + continue; + AddSubItem (new ListViewSubItem (owner, item)); + } + owner.Layout (); + owner.Invalidate (); + } + + public void AddRange (string [] items, Color foreColor, + Color backColor, Font font) + { + if (items == null) + throw new ArgumentNullException ("items"); + + foreach (string item in items) { + if (item == null) + continue; + + AddSubItem (new ListViewSubItem (owner, item, foreColor, backColor, font)); + } + owner.Layout (); + owner.Invalidate (); + } + + void AddSubItem (ListViewSubItem subItem) + { + subItem.owner = owner; + list.Add (subItem); + + //UIA Framework + subItem.UIATextChanged += OnUIASubItemTextChanged; + } + + public void Clear () + { + list.Clear (); + } + + public bool Contains (ListViewSubItem subItem) + { + return list.Contains (subItem); + } + + public virtual bool ContainsKey (string key) + { + return IndexOfKey (key) != -1; + } + + public IEnumerator GetEnumerator () + { + return list.GetEnumerator (); + } + + void ICollection.CopyTo (Array dest, int index) + { + list.CopyTo (dest, index); + } + + int IList.Add (object item) + { + if (! (item is ListViewSubItem)) { + throw new ArgumentException ("Not of type ListViewSubItem", "item"); + } + + ListViewSubItem sub_item = (ListViewSubItem) item; + sub_item.owner = this.owner; + //UIA Framework + sub_item.UIATextChanged += OnUIASubItemTextChanged; + return list.Add (sub_item); + } + + bool IList.Contains (object subItem) + { + if (! (subItem is ListViewSubItem)) { + throw new ArgumentException ("Not of type ListViewSubItem", "subItem"); + } + + return this.Contains ((ListViewSubItem) subItem); + } + + int IList.IndexOf (object subItem) + { + if (! (subItem is ListViewSubItem)) { + throw new ArgumentException ("Not of type ListViewSubItem", "subItem"); + } + + return this.IndexOf ((ListViewSubItem) subItem); + } + + void IList.Insert (int index, object item) + { + if (! (item is ListViewSubItem)) { + throw new ArgumentException ("Not of type ListViewSubItem", "item"); + } + + this.Insert (index, (ListViewSubItem) item); + } + + void IList.Remove (object item) + { + if (! (item is ListViewSubItem)) { + throw new ArgumentException ("Not of type ListViewSubItem", "item"); + } + + this.Remove ((ListViewSubItem) item); + } + + public int IndexOf (ListViewSubItem subItem) + { + return list.IndexOf (subItem); + } + + public virtual int IndexOfKey (string key) + { + if (key == null || key.Length == 0) + return -1; + + for (int i = 0; i < list.Count; i++) { + ListViewSubItem l = (ListViewSubItem) list [i]; + if (String.Compare (l.Name, key, true) == 0) + return i; + } + + return -1; + } + + public void Insert (int index, ListViewSubItem item) + { + item.owner = this.owner; + list.Insert (index, item); + owner.Layout (); + owner.Invalidate (); + + //UIA Framework + item.UIATextChanged += OnUIASubItemTextChanged; + } + + public void Remove (ListViewSubItem item) + { + list.Remove (item); + owner.Layout (); + owner.Invalidate (); + + //UIA Framework + item.UIATextChanged -= OnUIASubItemTextChanged; + } + + public virtual void RemoveByKey (string key) + { + int idx = IndexOfKey (key); + if (idx != -1) + RemoveAt (idx); + } + + public void RemoveAt (int index) + { + //UIA Framework + if (index >= 0 && index < list.Count) + ((ListViewSubItem) list [index]).UIATextChanged -= OnUIASubItemTextChanged; + + list.RemoveAt (index); + + } + #endregion // Public Methods + #region UIA Event Handler + + private void OnUIASubItemTextChanged (object sender, EventArgs args) + { + owner.OnUIASubItemTextChanged (new LabelEditEventArgs (list.IndexOf (sender))); + } + + #endregion + + + } + #endregion // Subclasses + } +} |