private Rectangle button_area;
private Rectangle listbox_area;
private const int button_width = 16;
+ bool drop_down_button_entered;
#if NET_2_0
private AutoCompleteStringCollection auto_complete_custom_source = null;
private AutoCompleteMode auto_complete_mode = AutoCompleteMode.None;
MouseUp += new MouseEventHandler (OnMouseUpCB);
MouseMove += new MouseEventHandler (OnMouseMoveCB);
MouseWheel += new MouseEventHandler (OnMouseWheelCB);
+ MouseEnter += new EventHandler (OnMouseEnter);
+ MouseLeave += new EventHandler (OnMouseLeave);
KeyDown +=new KeyEventHandler(OnKeyDownCB);
}
if(auto_complete_custom_source != null)
auto_complete_custom_source.CollectionChanged += new CollectionChangeEventHandler (OnAutoCompleteCustomSourceChanged);
+
+ SetTextBoxAutoCompleteData ();
}
}
throw new InvalidEnumArgumentException (Locale.GetText ("Enum argument value '{0}' is not valid for AutoCompleteMode", value));
auto_complete_mode = value;
+ SetTextBoxAutoCompleteData ();
}
}
throw new InvalidEnumArgumentException (Locale.GetText ("Enum argument value '{0}' is not valid for AutoCompleteSource", value));
auto_complete_source = value;
+ SetTextBoxAutoCompleteData ();
+ }
+ }
+
+ void SetTextBoxAutoCompleteData ()
+ {
+ if (textbox_ctrl == null)
+ return;
+
+ textbox_ctrl.AutoCompleteMode = auto_complete_mode;
+
+ if (auto_complete_source == AutoCompleteSource.ListItems) {
+ textbox_ctrl.AutoCompleteSource = AutoCompleteSource.CustomSource;
+ textbox_ctrl.AutoCompleteCustomSource = null;
+ textbox_ctrl.AutoCompleteInternalSource = this;
+ } else {
+ textbox_ctrl.AutoCompleteSource = auto_complete_source;
+ textbox_ctrl.AutoCompleteCustomSource = auto_complete_custom_source;
+ textbox_ctrl.AutoCompleteInternalSource = null;
}
}
#endif
[DefaultValue ((string)null)]
[AttributeProvider (typeof (IListSource))]
[RefreshProperties (RefreshProperties.Repaint)]
+ [MWFCategory("Data")]
public new object DataSource {
get { return base.DataSource; }
set { base.DataSource = value; }
[RefreshProperties(RefreshProperties.Repaint)]
[DefaultValue (DrawMode.Normal)]
+ [MWFCategory("Behavior")]
public DrawMode DrawMode {
get { return draw_mode; }
set {
[Browsable (true)]
[DefaultValue (106)]
[EditorBrowsable (EditorBrowsableState.Always)]
+ [MWFCategory("Behavior")]
public int DropDownHeight {
get {
return drop_down_height;
[DefaultValue (ComboBoxStyle.DropDown)]
[RefreshProperties(RefreshProperties.Repaint)]
+ [MWFCategory("Appearance")]
public ComboBoxStyle DropDownStyle {
get { return dropdown_style; }
set {
show_dropdown_button = false;
CreateComboListBox ();
-
- if (IsHandleCreated) {
- Controls.AddImplicit (listbox_ctrl);
- listbox_ctrl.Visible = true;
- }
+ Controls.AddImplicit (listbox_ctrl);
+ listbox_ctrl.Visible = true;
+
+ // This should give us a 150 default height
+ // for Simple mode if size hasn't been set
+ // (DefaultSize doesn't work for us in this case)
+ if (requested_height == -1)
+ requested_height = 150;
} else {
show_dropdown_button = true;
button_state = ButtonState.Normal;
textbox_ctrl.Text = GetItemText (selected_item);
textbox_ctrl.BorderStyle = BorderStyle.None;
textbox_ctrl.TextChanged += new EventHandler (OnTextChangedEdit);
+ textbox_ctrl.KeyPress += new KeyPressEventHandler (OnTextKeyPress);
textbox_ctrl.Click += new EventHandler (OnTextBoxClick);
textbox_ctrl.ContextMenu = ContextMenu;
if (IsHandleCreated == true)
Controls.AddImplicit (textbox_ctrl);
+#if NET_2_0
+ SetTextBoxAutoCompleteData ();
+#endif
}
ResumeLayout ();
}
}
+ [MWFCategory("Behavior")]
public int DropDownWidth {
get {
if (dropdown_width == -1)
if (value)
DropDownListBox ();
else
- listbox_ctrl.Hide ();
+ listbox_ctrl.HideWindow ();
}
}
#if NET_2_0
[DefaultValue (FlatStyle.Standard)]
[Localizable (true)]
+ [MWFCategory("Appearance")]
public FlatStyle FlatStyle {
get { return flat_style; }
set {
[DefaultValue (true)]
[Localizable (true)]
+ [MWFCategory("Behavior")]
public bool IntegralHeight {
get { return integral_height; }
set {
}
[Localizable (true)]
+ [MWFCategory("Behavior")]
public int ItemHeight {
get {
if (item_height == -1) {
#if NET_2_0
[MergableProperty (false)]
#endif
+ [MWFCategory("Data")]
public ComboBox.ObjectCollection Items {
get { return items; }
}
[DefaultValue (8)]
[Localizable (true)]
+ [MWFCategory("Behavior")]
public int MaxDropDownItems {
get { return maxdrop_items; }
set {
[DefaultValue (0)]
[Localizable (true)]
+ [MWFCategory("Behavior")]
public int MaxLength {
get { return max_length; }
set {
[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
[Browsable (false)]
public int PreferredHeight {
- get {
- return ItemHeight + 6;
- }
+ get { return Font.Height + 8; }
}
[Browsable (false)]
if (dropdown_style != ComboBoxStyle.DropDownList) {
if (value == -1)
- SetControlText("");
+ SetControlText (string.Empty, false);
else
- SetControlText (GetItemText (Items [value]));
+ SetControlText (GetItemText (Items [value]), false);
}
if (DropDownStyle == ComboBoxStyle.DropDownList)
object item = selected_index == -1 ? null : Items [selected_index];
if (item == value)
return;
- SelectedIndex = Items.IndexOf (value);
+
+ if (value == null)
+ SelectedIndex = -1;
+ else
+ SelectedIndex = Items.IndexOf (value);
}
}
}
[DefaultValue (false)]
+ [MWFCategory("Behavior")]
public bool Sorted {
get { return sorted; }
set {
if (value == null) {
if (SelectedIndex == -1) {
if (dropdown_style != ComboBoxStyle.DropDownList)
- SetControlText ("");
+ SetControlText (string.Empty, false);
} else {
SelectedIndex = -1;
}
#endregion Public Properties
+ #region Internal Properties
+ internal Rectangle ButtonArea {
+ get { return button_area; }
+ }
+
+ internal Rectangle TextArea {
+ get { return text_area; }
+ }
+ #endregion
+
+ #region UIA Framework Properties
+
+ internal TextBox UIATextBox {
+ get { return textbox_ctrl; }
+ }
+
+ #endregion UIA Framework Properties
+
#region Public Methods
#if NET_2_0
[Obsolete ("This method has been deprecated")]
{
base.OnDisplayMemberChanged (e);
- if (DataManager == null || !IsHandleCreated)
+ if (DataManager == null)
+ return;
+
+ if (selected_index != -1 && DropDownStyle != ComboBoxStyle.DropDownList)
+ SetControlText (GetItemText (Items [selected_index]), true);
+
+ if (!IsHandleCreated)
return;
- BindDataItems ();
SelectedIndex = DataManager.Position;
+ Invalidate ();
}
protected virtual void OnDrawItem (DrawItemEventArgs e)
{
+ DrawItemEventHandler eh = (DrawItemEventHandler)(Events [DrawItemEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ internal void HandleDrawItem (DrawItemEventArgs e)
+ {
+ // Only raise OnDrawItem if we are in an OwnerDraw mode
switch (DrawMode) {
- case DrawMode.OwnerDrawFixed:
- case DrawMode.OwnerDrawVariable:
- DrawItemEventHandler eh = (DrawItemEventHandler)(Events [DrawItemEvent]);
- if (eh != null)
- eh (this, e);
- break;
- default:
- ThemeEngine.Current.DrawComboBoxItem (this, e);
- break;
+ case DrawMode.OwnerDrawFixed:
+ case DrawMode.OwnerDrawVariable:
+ OnDrawItem (e);
+ break;
+ default:
+ ThemeEngine.Current.DrawComboBoxItem (this, e);
+ break;
}
}
if (textbox_ctrl != null)
textbox_ctrl.Font = Font;
- if (!item_height_specified) {
- SizeF sz = TextRenderer.MeasureString ("The quick brown Fox", Font);
- item_height = (int) sz.Height;
- }
+ if (!item_height_specified)
+ item_height = Font.Height + 2;
if (IntegralHeight)
UpdateComboBoxBounds ();
{
base.OnHandleCreated (e);
+ SetBoundsInternal (Left, Top, Width, PreferredHeight, BoundsSpecified.None);
+
if (textbox_ctrl != null)
Controls.AddImplicit (textbox_ctrl);
LayoutComboBox ();
+ UpdateComboBoxBounds ();
}
protected override void OnHandleDestroyed (EventArgs e)
protected override void OnKeyPress (KeyPressEventArgs e)
{
- // int index = FindStringCaseInsensitive (e.KeyChar.ToString (), SelectedIndex);
- //if (index != -1)
- // SelectedIndex = index;
+ if (dropdown_style == ComboBoxStyle.DropDownList) {
+ int index = FindStringCaseInsensitive (e.KeyChar.ToString (), SelectedIndex + 1);
+ if (index != -1) {
+ SelectedIndex = index;
+ if (DroppedDown) { //Scroll into view
+ if (SelectedIndex >= listbox_ctrl.LastVisibleItem ())
+ listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.LastVisibleItem () + 1);
+ // Or, selecting an item earlier in the list.
+ if (SelectedIndex < listbox_ctrl.FirstVisibleItem ())
+ listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.FirstVisibleItem ());
+ }
+ }
+ }
base.OnKeyPress (e);
}
for (int i = 0; i < Items.Count; i++) {
RefreshItem (i);
}
+
+ LayoutComboBox ();
+ Refresh ();
+
+ if (selected_index != -1 && DropDownStyle != ComboBoxStyle.DropDownList)
+ SetControlText (GetItemText (Items [selected_index]), false);
}
public override void ResetText ()
#endif
#if NET_2_0
- private float current_factor_width = 1f;
-
- // WTF? WTF? WTF????
- // I am sure this is tied to something I missed that makes this make sense.
- // Every time you double the size of the control, subtract 4 pixels from it
protected override void ScaleControl (SizeF factor, BoundsSpecified specified)
{
- // Never change the ComboBox's height
- specified &= ~BoundsSpecified.Height;
-
- int width = ClientSize.Width;
-
- // Go back to the original (un-4-subtracted) size
- if ((specified & BoundsSpecified.Width) == BoundsSpecified.Width)
- width += (int)(((current_factor_width) - 1f) * 4.0f);
-
- Rectangle new_bounds = GetScaledBounds (new Rectangle (Location, new Size (width, ClientSize.Height)), factor, specified);
-
- // Subtract 4 for every time the control is 'doubled'
- if ((specified & BoundsSpecified.Width) == BoundsSpecified.Width) {
- new_bounds.Width += (int)(((factor.Width * current_factor_width) - 1f) * -4.0f);
- current_factor_width *= factor.Width;
- }
-
- SetBounds (new_bounds.X, new_bounds.Y, new_bounds.Width, new_bounds.Height, specified);
+ base.ScaleControl (factor, specified);
}
#endif
protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified)
{
- if ((specified & BoundsSpecified.Height) != 0) {
- requested_height = height;
+ bool vertically_anchored = (Anchor & AnchorStyles.Top) != 0 && (Anchor & AnchorStyles.Bottom) != 0;
+ bool vertically_docked = Dock == DockStyle.Left || Dock == DockStyle.Right || Dock == DockStyle.Fill;
- if (DropDownStyle == ComboBoxStyle.Simple && height > PreferredHeight) {
- if (IntegralHeight) {
- int border = ThemeEngine.Current.Border3DSize.Height;
- int lb_height = height - PreferredHeight - 2;
- if (lb_height - 2 * border > ItemHeight) {
- int partial = (lb_height - 2 * border) % ItemHeight;
- height -= partial;
- } else
- height = PreferredHeight;
- }
- } else
- height = PreferredHeight;
+ if ((specified & BoundsSpecified.Height) != 0 ||
+ (specified == BoundsSpecified.None && (vertically_anchored || vertically_docked))) {
+
+ requested_height = height;
+ height = SnapHeight (height);
}
base.SetBoundsCore (x, y, width, height, specified);
case Msg.WM_KEYUP:
case Msg.WM_KEYDOWN:
Keys keys = (Keys) m.WParam.ToInt32 ();
+#if NET_2_0
+ // Don't pass the message to base if auto complete is being used and available.
+ if (textbox_ctrl != null && textbox_ctrl.CanNavigateAutoCompleteList) {
+ XplatUI.SendMessage (textbox_ctrl.Handle, (Msg) m.Msg, m.WParam, m.LParam);
+ return;
+ }
+#endif
if (keys == Keys.Up || keys == Keys.Down)
break;
goto case Msg.WM_CHAR;
is_flat = style == FlatStyle.Flat || style == FlatStyle.Popup;
#endif
- if (DropDownStyle == ComboBoxStyle.Simple)
- dc.FillRectangle (theme.ResPool.GetSolidBrush (Parent.BackColor), ClientRectangle);
-
- if (style == FlatStyle.Popup && (is_entered || Focused)) {
- Rectangle area = text_area;
- area.Height -= 1;
- area.Width -= 1;
- dc.DrawRectangle (theme.ResPool.GetPen (SystemColors.ControlDark), area);
- dc.DrawLine (theme.ResPool.GetPen (SystemColors.ControlDark), button_area.X - 1, button_area.Top, button_area.X - 1, button_area.Bottom);
- }
- if (!is_flat && clip.IntersectsWith (text_area))
- ControlPaint.DrawBorder3D (dc, text_area, Border3DStyle.Sunken);
+ theme.ComboBoxDrawBackground (this, dc, clip, style);
int border = theme.Border3DSize.Width;
}
state |= DrawItemState.ComboBoxEdit;
- OnDrawItem (new DrawItemEventArgs (dc, Font, item_rect, SelectedIndex, state, ForeColor, BackColor));
+ HandleDrawItem (new DrawItemEventArgs (dc, Font, item_rect, SelectedIndex, state, ForeColor, BackColor));
}
if (show_dropdown_button) {
- dc.FillRectangle (theme.ResPool.GetSolidBrush (theme.ColorControl), button_area);
-
ButtonState current_state;
if (is_enabled)
current_state = button_state;
else
current_state = ButtonState.Inactive;
+ if (is_flat || theme.ComboBoxNormalDropDownButtonHasTransparentBackground (this, current_state))
+ dc.FillRectangle (theme.ResPool.GetSolidBrush (theme.ColorControl), button_area);
+
if (is_flat) {
theme.DrawFlatStyleComboButton (dc, button_area, current_state);
} else {
- theme.CPDrawComboButton (dc, button_area, current_state);
+ theme.ComboBoxDrawNormalDropDownButton (this, dc, clip, button_area, current_state);
}
}
}
+ internal bool DropDownButtonEntered {
+ get { return drop_down_button_entered; }
+ private set {
+ if (drop_down_button_entered == value)
+ return;
+ drop_down_button_entered = value;
+ if (ThemeEngine.Current.ComboBoxDropDownButtonHasHotElementStyle (this))
+ Invalidate (button_area);
+ }
+ }
+
internal void DropDownListBox ()
{
+ DropDownButtonEntered = false;
+
if (DropDownStyle == ComboBoxStyle.Simple)
return;
listbox_ctrl.Location = PointToScreen (new Point (text_area.X, text_area.Y + text_area.Height));
+ FindMatchOrSetIndex(SelectedIndex);
+
+#if NET_2_0
+ if (textbox_ctrl != null)
+ textbox_ctrl.HideAutoCompleteList ();
+#endif
+
if (listbox_ctrl.ShowWindow ())
dropped_down = true;
if (DropDownStyle == ComboBoxStyle.Simple)
return;
+ FindMatchOrSetIndex (SelectedIndex);
button_state = ButtonState.Normal;
Invalidate (button_area);
dropped_down = false;
return -1;
}
+ // Search in the list for the substring, starting the search at the list
+ // position specified, the search wraps thus covering all the list.
internal int FindStringCaseInsensitive (string search, int start_index)
{
if (search.Length == 0) {
return -1;
}
+ // Accept from first item to after last item. i.e. all cases of (SelectedIndex+1).
+ if (start_index < 0 || start_index > Items.Count)
+ throw new ArgumentOutOfRangeException("start_index");
for (int i = 0; i < Items.Count; i++) {
int index = (i + start_index) % Items.Count;
}
}
+ internal void RestoreContextMenu ()
+ {
+ textbox_ctrl.RestoreContextMenu ();
+ }
+
private void OnKeyDownCB(object sender, KeyEventArgs e)
{
if (Items.Count == 0)
return;
+ int offset;
switch (e.KeyCode)
{
case Keys.Up:
- SelectedIndex = Math.Max(SelectedIndex-1, 0);
+ FindMatchOrSetIndex(Math.Max(SelectedIndex - 1, 0));
+
+ if (DroppedDown)
+ if (SelectedIndex < listbox_ctrl.FirstVisibleItem ())
+ listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.FirstVisibleItem ());
break;
case Keys.Down:
- SelectedIndex = Math.Min(SelectedIndex+1, Items.Count-1);
+ if ((e.Modifiers & Keys.Alt) == Keys.Alt)
+ DropDownListBox ();
+ else
+ FindMatchOrSetIndex(Math.Min(SelectedIndex + 1, Items.Count - 1));
+
+ if (DroppedDown)
+ if (SelectedIndex >= listbox_ctrl.LastVisibleItem ())
+ listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.LastVisibleItem () + 1);
break;
case Keys.PageUp:
- if (listbox_ctrl != null)
- SelectedIndex = Math.Max(SelectedIndex- (listbox_ctrl.page_size-1), 0);
+ offset = listbox_ctrl == null ? MaxDropDownItems - 1 : listbox_ctrl.page_size - 1;
+ if (offset < 1)
+ offset = 1;
+
+ SelectedIndex = Math.Max (SelectedIndex - offset, 0);
+
+ if (DroppedDown)
+ if (SelectedIndex < listbox_ctrl.FirstVisibleItem ())
+ listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.FirstVisibleItem ());
break;
case Keys.PageDown:
- if (listbox_ctrl != null)
- SelectedIndex = Math.Min(SelectedIndex+(listbox_ctrl.page_size-1), Items.Count-1);
+ if (SelectedIndex == -1) {
+ SelectedIndex = 0;
+ if (dropdown_style != ComboBoxStyle.Simple)
+ return;
+ }
+
+ offset = listbox_ctrl == null ? MaxDropDownItems - 1 : listbox_ctrl.page_size - 1;
+ if (offset < 1)
+ offset = 1;
+
+ SelectedIndex = Math.Min (SelectedIndex + offset, Items.Count - 1);
+
+ if (DroppedDown)
+ if (SelectedIndex >= listbox_ctrl.LastVisibleItem ())
+ listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.LastVisibleItem () + 1);
break;
+ case Keys.Enter:
+ case Keys.Escape:
+ DropDownListBoxFinished ();
+ break;
+
+ case Keys.Home:
+ if (dropdown_style == ComboBoxStyle.DropDownList) {
+ SelectedIndex = 0;
+
+ if (DroppedDown)
+ if (SelectedIndex < listbox_ctrl.FirstVisibleItem ())
+ listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.FirstVisibleItem ());
+ }
+
+ break;
+ case Keys.End:
+ if (dropdown_style == ComboBoxStyle.DropDownList) {
+ SelectedIndex = Items.Count - 1;
+
+ if (DroppedDown)
+ if (SelectedIndex >= listbox_ctrl.LastVisibleItem ())
+ listbox_ctrl.Scroll (SelectedIndex - listbox_ctrl.LastVisibleItem () + 1);
+ }
+
+ break;
default:
break;
}
}
+
+ // If no item is currently selected, and an item is found matching the text
+ // in the textbox, then selected that item. Otherwise the item at the given
+ // index is selected.
+ private void FindMatchOrSetIndex(int index)
+ {
+ int match = -1;
+ if (SelectedIndex == -1 && Text.Length != 0)
+ match = FindStringCaseInsensitive(Text);
+ if (match != -1)
+ SelectedIndex = match;
+ else
+ SelectedIndex = index;
+ }
void OnMouseDownCB (object sender, MouseEventArgs e)
{
Capture = true;
}
+ void OnMouseEnter (object sender, EventArgs e)
+ {
+ if (ThemeEngine.Current.CombBoxBackgroundHasHotElementStyle (this))
+ Invalidate ();
+ }
+
+ void OnMouseLeave (object sender, EventArgs e)
+ {
+ if (ThemeEngine.Current.CombBoxBackgroundHasHotElementStyle (this)) {
+ drop_down_button_entered = false;
+ Invalidate ();
+ } else {
+ if (show_dropdown_button)
+ DropDownButtonEntered = false;
+ }
+ }
+
void OnMouseMoveCB (object sender, MouseEventArgs e)
{
+ if (show_dropdown_button && !dropped_down)
+ DropDownButtonEntered = button_area.Contains (e.Location);
+
if (DropDownStyle == ComboBoxStyle.Simple)
return;
{
if (process_textchanged_event == false)
return;
-
- OnTextChanged (EventArgs.Empty);
int item = FindStringCaseInsensitive (textbox_ctrl.Text);
- if (item == -1)
+ if (item == -1) {
+ // Setting base.Text below will raise this event
+ // if we found something
+ OnTextChanged (EventArgs.Empty);
return;
-
+ }
+
// TODO: THIS IS BROKEN-ISH
// I don't think we should hilight, and setting the top item does weirdness
// when there is no scrollbar
base.Text = textbox_ctrl.Text;
}
-
- internal void SetControlText (string s)
+
+ private void OnTextKeyPress (object sender, KeyPressEventArgs e)
+ {
+ selected_index = -1;
+ }
+
+ internal void SetControlText (string s, bool suppressTextChanged)
{
- process_textchanged_event = false;
+ if (suppressTextChanged)
+ process_textchanged_event = false;
+
textbox_ctrl.Text = s;
textbox_ctrl.SelectAll ();
process_textchanged_event = true;
// Save the requested height since set bounds can destroy it
int save_height = requested_height;
- SetBounds (bounds.X, bounds.Y, bounds.Width, requested_height, BoundsSpecified.Height);
+ SetBounds (bounds.X, bounds.Y, bounds.Width, SnapHeight (requested_height),
+ BoundsSpecified.Height);
requested_height = save_height;
}
+ int SnapHeight (int height)
+ {
+ if (DropDownStyle == ComboBoxStyle.Simple && height > PreferredHeight) {
+ if (IntegralHeight) {
+ int border = ThemeEngine.Current.Border3DSize.Height;
+ int lb_height = (height - PreferredHeight - 2) - border * 2;
+ if (lb_height > ItemHeight) {
+ int partial = (lb_height) % ItemHeight;
+ height -= partial;
+ } else if (lb_height < ItemHeight)
+ height = PreferredHeight;
+ }
+ } else
+ height = PreferredHeight;
+
+ return height;
+ }
+
private void UpdatedItems ()
{
if (listbox_ctrl != null) {
private ComboBox owner;
internal ArrayList object_items = new ArrayList ();
+
+ #region UIA Framework Events
+
+#if NET_2_0
+ //NOTE:
+ // We are using Reflection to add/remove internal events.
+ // Class ListProvider uses the events.
+ //
+ //Event used to generate UIA StructureChangedEvent
+ static object UIACollectionChangedEvent = new object ();
+
+ internal event CollectionChangeEventHandler UIACollectionChanged {
+ add { owner.Events.AddHandler (UIACollectionChangedEvent, value); }
+ remove { owner.Events.RemoveHandler (UIACollectionChangedEvent, value); }
+ }
+
+ internal void OnUIACollectionChangedEvent (CollectionChangeEventArgs args)
+ {
+ CollectionChangeEventHandler eh
+ = (CollectionChangeEventHandler) owner.Events [UIACollectionChangedEvent];
+ if (eh != null)
+ eh (owner, args);
+ }
+#endif
+
+ #endregion UIA Framework Events
public ObjectCollection (ComboBox owner)
{
if (value == null)
throw new ArgumentNullException ("value");
+#if NET_2_0
+ //UIA Framework event: Item Removed
+ OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Remove, object_items [index]));
+#endif
+
object_items[index] = value;
+
+#if NET_2_0
+ //UIA Framework event: Item Added
+ OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, value));
+#endif
+
if (owner.listbox_ctrl != null)
owner.listbox_ctrl.InvalidateItem (index);
if (index == owner.SelectedIndex) {
object_items.Clear ();
owner.UpdatedItems ();
owner.Refresh ();
+
+#if NET_2_0
+ //UIA Framework event: Items list cleared
+ OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Refresh, null));
+#endif
}
public bool Contains (object value)
return object_items.Contains (value);
}
- public void CopyTo (object[] dest, int arrayIndex)
+#if NET_2_0
+ public void CopyTo (object [] destination, int arrayIndex)
+ {
+ object_items.CopyTo (destination, arrayIndex);
+ }
+
+ void ICollection.CopyTo (Array destination, int index)
+ {
+ object_items.CopyTo (destination, index);
+ }
+#else
+ public void CopyTo (object [] dest, int arrayIndex)
{
object_items.CopyTo (dest, arrayIndex);
}
{
object_items.CopyTo (dest, index);
}
+#endif
public IEnumerator GetEnumerator ()
{
if (owner.Sorted)
AddItem (item);
- else
+ else {
object_items.Insert (index, item);
+#if NET_2_0
+ //UIA Framework event: Item added
+ OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, item));
+#endif
+ }
owner.EndUpdate (); // Calls UpdatedItems
}
if (index == owner.SelectedIndex)
owner.SelectedIndex = -1;
+#if NET_2_0
+ object removed = object_items [index];
+#endif
+
+
object_items.RemoveAt (index);
owner.UpdatedItems ();
+
+#if NET_2_0
+ //UIA Framework event: Item removed
+ OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Remove, removed));
+#endif
}
#endregion Public Methods
foreach (object o in object_items) {
if (String.Compare (item.ToString (), o.ToString ()) < 0) {
object_items.Insert (index, item);
+
+ // If we added the new item before the selectedindex
+ // bump the selectedindex by one, behavior differs if
+ // Handle has not been created.
+ if (index <= owner.selected_index && owner.IsHandleCreated)
+ owner.selected_index++;
+
+#if NET_2_0
+ //UIA Framework event: Item added
+ OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, item));
+#endif
+
return index;
}
index++;
}
}
object_items.Add (item);
+
+#if NET_2_0
+ //UIA Framework event: Item added
+ OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, item));
+#endif
+
return object_items.Count - 1;
}
internal void Sort ()
{
- object_items.Sort ();
+ // If the objects the user put here don't have their own comparer,
+ // use one that compares based on the object's ToString
+ if (object_items.Count > 0 && object_items[0] is IComparer)
+ object_items.Sort ();
+ else
+ object_items.Sort (new ObjectComparer (owner));
}
+ private class ObjectComparer : IComparer
+ {
+ private ListControl owner;
+
+ public ObjectComparer (ListControl owner)
+ {
+ this.owner = owner;
+ }
+
+ #region IComparer Members
+ public int Compare (object x, object y)
+ {
+ return string.Compare (owner.GetItemText (x), owner.GetItemText (y));
+ }
+ #endregion
+ }
#endregion Private Methods
}
}
}
- protected override void Select (bool directed, bool forward)
- {
- // Do nothing, we never want to be selected
- }
-
internal override bool InternalCapture {
get {
return Capture;
{
int width, height;
bool show_scrollbar = false;
-
+
if (owner.DropDownStyle == ComboBoxStyle.Simple) {
Rectangle area = owner.listbox_area;
width = area.Width;
height = area.Height;
+
+ // No calculation needed
+ if (height <= 0 || width <= 0)
+ return;
}
else { // DropDown or DropDownList
}
}
- page_size = height / owner.ItemHeight;
+ page_size = Math.Max (height / owner.ItemHeight, 1);
+
+ ComboBoxStyle dropdown_style = owner.DropDownStyle;
+ if ((dropdown_style != ComboBoxStyle.Simple && owner.Items.Count <= owner.MaxDropDownItems)
+ || (dropdown_style == ComboBoxStyle.Simple && owner.Items.Count * owner.ItemHeight < height)) {
- if (owner.Items.Count <= owner.MaxDropDownItems) {
if (vscrollbar_ctrl != null)
vscrollbar_ctrl.Visible = false;
- if (owner.DropDownStyle != ComboBoxStyle.Simple)
+ if (dropdown_style != ComboBoxStyle.Simple)
height = owner.ItemHeight * owner.items.Count;
} else {
/* Need vertical scrollbar */
vscrollbar_ctrl.Dock = DockStyle.Right;
- vscrollbar_ctrl.Maximum = owner.Items.Count - 2;
+ vscrollbar_ctrl.Maximum = owner.Items.Count - 1;
#if NET_2_0
- int large = page_size - 1;
+ int large = page_size;
#else
- int large = (owner.DropDownStyle == ComboBoxStyle.Simple ? page_size : owner.maxdrop_items) - 1;
+ int large = (dropdown_style == ComboBoxStyle.Simple ? page_size : owner.maxdrop_items) - 1;
#endif
- if (large < 0)
- large = 0;
+ if (large < 1)
+ large = 1;
vscrollbar_ctrl.LargeChange = large;
show_scrollbar = vscrollbar_ctrl.Visible = true;
state |= DrawItemState.Focus;
}
}
-
- owner.OnDrawItem (new DrawItemEventArgs (dc, owner.Font, item_rect,
+
+ owner.HandleDrawItem (new DrawItemEventArgs (dc, owner.Font, item_rect,
i, state, owner.ForeColor, owner.BackColor));
}
}
Invalidate (GetItemDisplayRectangle (index, top_item));
}
- private int LastVisibleItem ()
+ public int LastVisibleItem ()
{
Rectangle item_rect;
int top_y = textarea_drawable.Y + textarea_drawable.Height;
Invalidate ();
}
+ public int FirstVisibleItem ()
+ {
+ return top_item;
+ }
+
bool scrollbar_grabbed = false;
bool InScrollBar {
return;
}
+ bool is_change = owner.SelectedIndex != index;
+
owner.SelectedIndex = index;
owner.OnSelectionChangeCommitted (new EventArgs ());
+
+ // If the user selected the already selected item, SelectedIndex
+ // won't fire these events, but .Net does, so we do it here
+ if (!is_change) {
+ owner.OnSelectedValueChanged (EventArgs.Empty);
+ owner.OnSelectedIndexChanged (EventArgs.Empty);
+ }
+
HideWindow ();
}
if (delta == 0 || vscrollbar_ctrl == null || !vscrollbar_ctrl.Visible)
return;
- int max = owner.Items.Count - page_size;
+ int max = vscrollbar_ctrl.Maximum - page_size + 1;
int val = vscrollbar_ctrl.Value + delta;
if (val > max)
protected override void WndProc(ref Message m) {
if (m.Msg == (int)Msg.WM_SETFOCUS) {
- if (m.WParam != IntPtr.Zero) {
- XplatUI.SetFocus(m.WParam);
- }
+ owner.Select (false, true);
}
base.WndProc (ref m);
}
projects / mono.git / blobdiff