#region Internal methods
internal override void HaveDoubleClick() {
- if (DoubleClick != null) DoubleClick(this, EventArgs.Empty);
+ EventHandler eh = (EventHandler)(Events [DoubleClickEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
#endregion // Internal methods
#endregion // Protected Instance Methods
#region Events
+ static object DoubleClickEvent = new object ();
+
[Browsable(false)]
[EditorBrowsable (EditorBrowsableState.Advanced)]
- public event EventHandler DoubleClick;
+ public event EventHandler DoubleClick {
+ add { Events.AddHandler (DoubleClickEvent, value); }
+ remove { Events.RemoveHandler (DoubleClickEvent, value); }
+ }
#endregion // Events
}
}
+2006-12-01 Chris Toshok <toshok@ximian.com>
+
+ * Button.cs, PropertyGridTextBox.cs, ComboBox.cs,
+ SplitContainer.cs, Control.cs, StatusStrip.cs,
+ DataGridTableStyle.cs, MenuItem.cs, DomainUpDown.cs, ImageList.cs,
+ NumericTextBox.cs, NumericUpDown.cs, Panel.cs, CommonDialog.cs,
+ DataGrid.cs, ScrollBar.cs, TrackBar.cs, PictureBox.cs,
+ DateTimePicker.cs, StatusBar.cs, Form.cs, PrintPreviewDialog.cs,
+ Label.cs, UserControl.cs, CheckBox.cs, RadioButton.cs,
+ LinkLabel.cs, ListControl.cs, PropertyGrid.cs, Splitter.cs,
+ MenuStrip.cs, FolderBrowserDialog.cs, NotifyIcon.cs,
+ TextBoxBase.cs, ListView.cs, DataGridBoolColumn.cs,
+ PrintPreviewControl.cs, RichTextBox.cs, ListBox.cs, TabControl.cs,
+ DataGridColumnStyle.cs, ContextMenu.cs, TreeView.cs:
+
+ do most of the work to convert our code over to use
+ System.ComponentModel.Component.Events for
+ adding/removing/dispatching events.
+
+
2006-11-30 Jonathan Pobst <monkey@jpobst.com>
* DataGridView.cs: Fix an ArgumentNullException reported
set {
if (value != appearance) {
appearance = value;
- if (AppearanceChanged != null) {
- AppearanceChanged(this, EventArgs.Empty);
- }
+ OnAppearanceChanged (EventArgs.Empty);
Redraw();
}
}
}
protected virtual void OnAppearanceChanged(EventArgs e) {
- if (AppearanceChanged != null) {
- AppearanceChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [AppearanceChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnCheckedChanged(EventArgs e) {
- if (CheckedChanged != null) {
- CheckedChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [CheckedChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnCheckStateChanged(EventArgs e) {
- if (CheckStateChanged != null) {
- CheckStateChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [CheckStateChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnClick(EventArgs e) {
#endregion // Protected Instance Methods
#region Events
- public event EventHandler AppearanceChanged;
- public event EventHandler CheckedChanged;
- public event EventHandler CheckStateChanged;
+ static object AppearanceChangedEvent = new object ();
+ static object CheckedChangedEvent = new object ();
+ static object CheckStateChangedEvent = new object ();
+
+ public event EventHandler AppearanceChanged {
+ add { Events.AddHandler (AppearanceChangedEvent, value); }
+ remove { Events.RemoveHandler (AppearanceChangedEvent, value); }
+ }
+
+ public event EventHandler CheckedChanged {
+ add { Events.AddHandler (CheckedChangedEvent, value); }
+ remove { Events.RemoveHandler (CheckedChangedEvent, value); }
+ }
+
+ public event EventHandler CheckStateChanged {
+ add { Events.AddHandler (CheckStateChangedEvent, value); }
+ remove { Events.RemoveHandler (CheckStateChangedEvent, value); }
+ }
#endregion // Events
#region Events
add { base.BackgroundImageChanged += value; }
remove { base.BackgroundImageChanged -= value; }
}
-
- public event DrawItemEventHandler DrawItem;
- public event EventHandler DropDown;
- public event EventHandler DropDownStyleChanged;
- public event MeasureItemEventHandler MeasureItem;
+
+ static object DrawItemEvent = new object ();
+ static object DropDownEvent = new object ();
+ static object DropDownStyleChangedEvent = new object ();
+ static object MeasureItemEvent = new object ();
+ static object SelectedIndexChangedEvent = new object ();
+ static object SelectionChangeCommittedEvent = new object ();
+
+ public event DrawItemEventHandler DrawItem {
+ add { Events.AddHandler (DrawItemEvent, value); }
+ remove { Events.RemoveHandler (DrawItemEvent, value); }
+ }
+
+ public event EventHandler DropDown {
+ add { Events.AddHandler (DropDownEvent, value); }
+ remove { Events.RemoveHandler (DropDownEvent, value); }
+ }
+
+ public event EventHandler DropDownStyleChanged {
+ add { Events.AddHandler (DropDownStyleChangedEvent, value); }
+ remove { Events.RemoveHandler (DropDownStyleChangedEvent, value); }
+ }
+
+ public event MeasureItemEventHandler MeasureItem {
+ add { Events.AddHandler (MeasureItemEvent, value); }
+ remove { Events.RemoveHandler (MeasureItemEvent, value); }
+ }
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
remove { base.Paint -= value; }
}
- public event EventHandler SelectedIndexChanged;
- public event EventHandler SelectionChangeCommitted;
+ public event EventHandler SelectedIndexChanged {
+ add { Events.AddHandler (SelectedIndexChangedEvent, value); }
+ remove { Events.RemoveHandler (SelectedIndexChangedEvent, value); }
+ }
+
+ public event EventHandler SelectionChangeCommitted {
+ add { Events.AddHandler (SelectionChangeCommittedEvent, value); }
+ remove { Events.RemoveHandler (SelectionChangeCommittedEvent, value); }
+ }
+
#endregion Events
#region Public Properties
switch (DrawMode) {
case DrawMode.OwnerDrawFixed:
case DrawMode.OwnerDrawVariable:
- if (DrawItem != null)
- DrawItem (this, e);
+ DrawItemEventHandler eh = (DrawItemEventHandler)(Events [DrawItemEvent]);
+ if (eh != null)
+ eh (this, e);
break;
default:
ThemeEngine.Current.DrawComboBoxItem (this, e);
protected virtual void OnDropDown (EventArgs e)
{
- if (DropDown != null)
- DropDown (this, e);
+ EventHandler eh = (EventHandler)(Events [DropDownEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnDropDownStyleChanged (EventArgs e)
{
- if (DropDownStyleChanged != null)
- DropDownStyleChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [DropDownStyleChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnFontChanged (EventArgs e)
protected virtual void OnMeasureItem (MeasureItemEventArgs e)
{
- if (MeasureItem != null)
- MeasureItem (this, e);
+ MeasureItemEventHandler eh = (MeasureItemEventHandler)(Events [MeasureItemEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnParentBackColorChanged (EventArgs e)
{
base.OnSelectedIndexChanged (e);
- if (SelectedIndexChanged != null)
- SelectedIndexChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [SelectedIndexChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnSelectedItemChanged (EventArgs e)
protected virtual void OnSelectionChangeCommitted (EventArgs e)
{
- if (SelectionChangeCommitted != null)
- SelectionChangeCommitted (this, e);
+ EventHandler eh = (EventHandler)(Events [SelectionChangeCommittedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void RefreshItem (int index)
}
protected virtual void OnHelpRequest(EventArgs e) {
- if (HelpRequest != null) {
- HelpRequest(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [HelpRequestEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual IntPtr OwnerWndProc(IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam) {
#endregion // Protected Instance Methods
#region Events
- public event EventHandler HelpRequest;
+ static object HelpRequestEvent = new object ();
+
+ public event EventHandler HelpRequest {
+ add { Events.AddHandler (HelpRequestEvent, value); }
+ remove { Events.RemoveHandler (HelpRequestEvent, value); }
+ }
#endregion // Events
}
}
private Control src_control;
#region Events
- public event EventHandler Popup;
+ static object PopupEvent = new object ();
+ public event EventHandler Popup {
+ add { Events.AddHandler (PopupEvent, value); }
+ remove { Events.RemoveHandler (PopupEvent, value); }
+ }
#endregion Events
public ContextMenu () : base (null)
protected internal virtual void OnPopup (EventArgs e)
{
- if (Popup != null)
- Popup (this, e);
+ EventHandler eh = (EventHandler)(Events [PopupEvent]);
+ if (eh != null)
+ eh (this, e);
}
public void Show (Control control, Point pos)
#region OnXXX methods
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnBackColorChanged(EventArgs e) {
- if (BackColorChanged!=null) BackColorChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [BackColorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
for (int i=0; i<child_controls.Count; i++) child_controls[i].OnParentBackColorChanged(e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnBackgroundImageChanged(EventArgs e) {
- if (BackgroundImageChanged!=null) BackgroundImageChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [BackgroundImageChangedEvent]);
+ if (eh != null)
+ eh (this, e);
for (int i=0; i<child_controls.Count; i++) child_controls[i].OnParentBackgroundImageChanged(e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnBindingContextChanged(EventArgs e) {
CheckDataBindings ();
- if (BindingContextChanged!=null) {
- BindingContextChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [BindingContextChangedEvent]);
+ if (eh != null)
+ eh (this, e);
for (int i=0; i<child_controls.Count; i++) child_controls[i].OnParentBindingContextChanged(e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnCausesValidationChanged(EventArgs e) {
- if (CausesValidationChanged!=null) CausesValidationChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [CausesValidationChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnChangeUICues(UICuesEventArgs e) {
- if (ChangeUICues!=null) ChangeUICues(this, e);
+ UICuesEventHandler eh = (UICuesEventHandler)(Events [ChangeUICuesEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnClick(EventArgs e) {
- if (Click!=null) Click(this, e);
+ EventHandler eh = (EventHandler)(Events [ClickEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnContextMenuChanged(EventArgs e) {
- if (ContextMenuChanged!=null) ContextMenuChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [ContextMenuChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnControlAdded(ControlEventArgs e) {
- if (ControlAdded!=null) ControlAdded(this, e);
+ ControlEventHandler eh = (ControlEventHandler)(Events [ControlAddedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnControlRemoved(ControlEventArgs e) {
- if (ControlRemoved!=null) ControlRemoved(this, e);
+ ControlEventHandler eh = (ControlEventHandler)(Events [ControlRemovedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnCursorChanged(EventArgs e) {
- if (CursorChanged!=null) CursorChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [CursorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnDockChanged(EventArgs e) {
- if (DockChanged!=null) DockChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [DockChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnDoubleClick(EventArgs e) {
- if (DoubleClick!=null) DoubleClick(this, e);
+ EventHandler eh = (EventHandler)(Events [DoubleClickEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnDragDrop(DragEventArgs drgevent) {
- if (DragDrop!=null) DragDrop(this, drgevent);
+ DragEventHandler eh = (DragEventHandler)(Events [DragDropEvent]);
+ if (eh != null)
+ eh (this, drgevent);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnDragEnter(DragEventArgs drgevent) {
- if (DragEnter!=null) DragEnter(this, drgevent);
+ DragEventHandler eh = (DragEventHandler)(Events [DragEnterEvent]);
+ if (eh != null)
+ eh (this, drgevent);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnDragLeave(EventArgs e) {
- if (DragLeave!=null) DragLeave(this, e);
+ EventHandler eh = (EventHandler)(Events [DragLeaveEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnDragOver(DragEventArgs drgevent) {
- if (DragOver!=null) DragOver(this, drgevent);
+ DragEventHandler eh = (DragEventHandler)(Events [DragOverEvent]);
+ if (eh != null)
+ eh (this, drgevent);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
Refresh();
}
- if (EnabledChanged != null) {
- EnabledChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [EnabledChangedEvent]);
+ if (eh != null)
+ eh (this, e);
for (int i=0; i<child_controls.Count; i++) {
child_controls[i].OnParentEnabledChanged(e);
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnEnter(EventArgs e) {
- if (Enter!=null) Enter(this, e);
+ EventHandler eh = (EventHandler)(Events [EnterEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnFontChanged(EventArgs e) {
- if (FontChanged!=null) FontChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [FontChangedEvent]);
+ if (eh != null)
+ eh (this, e);
for (int i=0; i<child_controls.Count; i++) child_controls[i].OnParentFontChanged(e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnForeColorChanged(EventArgs e) {
- if (ForeColorChanged!=null) ForeColorChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [ForeColorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
for (int i=0; i<child_controls.Count; i++) child_controls[i].OnParentForeColorChanged(e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnGiveFeedback(GiveFeedbackEventArgs gfbevent) {
- if (GiveFeedback!=null) GiveFeedback(this, gfbevent);
+ GiveFeedbackEventHandler eh = (GiveFeedbackEventHandler)(Events [GiveFeedbackEvent]);
+ if (eh != null)
+ eh (this, gfbevent);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnGotFocus(EventArgs e) {
- if (GotFocus!=null) GotFocus(this, e);
+ EventHandler eh = (EventHandler)(Events [GotFocusEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnHandleCreated(EventArgs e) {
- if (HandleCreated!=null) HandleCreated(this, e);
+ EventHandler eh = (EventHandler)(Events [HandleCreatedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnHandleDestroyed(EventArgs e) {
- if (HandleDestroyed!=null) HandleDestroyed(this, e);
+ EventHandler eh = (EventHandler)(Events [HandleDestroyedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnHelpRequested(HelpEventArgs hevent) {
- if (HelpRequested!=null) HelpRequested(this, hevent);
+ HelpEventHandler eh = (HelpEventHandler)(Events [HelpRequestedEvent]);
+ if (eh != null)
+ eh (this, hevent);
}
protected virtual void OnImeModeChanged(EventArgs e) {
- if (ImeModeChanged!=null) ImeModeChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [ImeModeChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
invalid_region.Union (r);
}
}
- if (Invalidated!=null) Invalidated(this, e);
+
+ InvalidateEventHandler eh = (InvalidateEventHandler)(Events [InvalidatedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
- protected virtual void OnKeyDown(KeyEventArgs e) {
- if (KeyDown!=null) KeyDown(this, e);
+ protected virtual void OnKeyDown(KeyEventArgs e) {
+ KeyEventHandler eh = (KeyEventHandler)(Events [KeyDownEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnKeyPress(KeyPressEventArgs e) {
- if (KeyPress!=null) KeyPress(this, e);
+ KeyPressEventHandler eh = (KeyPressEventHandler)(Events [KeyPressEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnKeyUp(KeyEventArgs e) {
- if (KeyUp!=null) KeyUp(this, e);
+ KeyEventHandler eh = (KeyEventHandler)(Events [KeyUpEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnLayout(LayoutEventArgs levent) {
- if (Layout!=null) Layout(this, levent);
+ LayoutEventHandler eh = (LayoutEventHandler)(Events [LayoutEvent]);
+ if (eh != null)
+ eh (this, levent);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnLeave(EventArgs e) {
- if (Leave!=null) Leave(this, e);
+ EventHandler eh = (EventHandler)(Events [LeaveEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnLocationChanged(EventArgs e) {
OnMove(e);
- if (LocationChanged!=null) LocationChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [LocationChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnLostFocus(EventArgs e) {
- if (LostFocus!=null) LostFocus(this, e);
+ EventHandler eh = (EventHandler)(Events [LostFocusEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMouseDown(MouseEventArgs e) {
- if (MouseDown!=null) MouseDown(this, e);
+ MouseEventHandler eh = (MouseEventHandler)(Events [MouseDownEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMouseEnter(EventArgs e) {
- if (MouseEnter!=null) MouseEnter(this, e);
+ EventHandler eh = (EventHandler)(Events [MouseEnterEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMouseHover(EventArgs e) {
- if (MouseHover!=null) MouseHover(this, e);
+ EventHandler eh = (EventHandler)(Events [MouseHoverEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMouseLeave(EventArgs e) {
- if (MouseLeave!=null) MouseLeave(this, e);
+ EventHandler eh = (EventHandler)(Events [MouseLeaveEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
- protected virtual void OnMouseMove(MouseEventArgs e) {
- if (MouseMove!=null) MouseMove(this, e);
+ protected virtual void OnMouseMove(MouseEventArgs e) {
+ MouseEventHandler eh = (MouseEventHandler)(Events [MouseMoveEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMouseUp(MouseEventArgs e) {
- if (MouseUp!=null) MouseUp(this, e);
+ MouseEventHandler eh = (MouseEventHandler)(Events [MouseUpEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMouseWheel(MouseEventArgs e) {
- if (MouseWheel!=null) MouseWheel(this, e);
+ MouseEventHandler eh = (MouseEventHandler)(Events [MouseWheelEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMove(EventArgs e) {
- if (Move!=null) Move(this, e);
+ EventHandler eh = (EventHandler)(Events [MoveEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnPaint(PaintEventArgs e) {
- if (Paint!=null) Paint(this, e);
+ PaintEventHandler eh = (PaintEventHandler)(Events [PaintEvent]);
+ if (eh != null)
+ eh (this, e);
}
internal virtual void OnPaintBackgroundInternal(PaintEventArgs e) {
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnParentChanged(EventArgs e) {
- if (ParentChanged!=null) ParentChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [ParentChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnQueryContinueDrag(QueryContinueDragEventArgs e) {
- if (QueryContinueDrag!=null) QueryContinueDrag(this, e);
+ QueryContinueDragEventHandler eh = (QueryContinueDragEventHandler)(Events [QueryContinueDragEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnResize(EventArgs e) {
- if (Resize!=null) Resize(this, e);
+ EventHandler eh = (EventHandler)(Events [ResizeEvent]);
+ if (eh != null)
+ eh (this, e);
PerformLayout(this, "bounds");
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnRightToLeftChanged(EventArgs e) {
- if (RightToLeftChanged!=null) RightToLeftChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [RightToLeftChangedEvent]);
+ if (eh != null)
+ eh (this, e);
for (int i=0; i<child_controls.Count; i++) child_controls[i].OnParentRightToLeftChanged(e);
}
protected virtual void OnSizeChanged(EventArgs e) {
InvalidateBuffers ();
OnResize(e);
- if (SizeChanged!=null) SizeChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [SizeChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnStyleChanged(EventArgs e) {
- if (StyleChanged!=null) StyleChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [StyleChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnSystemColorsChanged(EventArgs e) {
- if (SystemColorsChanged!=null) SystemColorsChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [SystemColorsChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnTabIndexChanged(EventArgs e) {
- if (TabIndexChanged!=null) TabIndexChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [TabIndexChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnTabStopChanged(EventArgs e) {
- if (TabStopChanged!=null) TabStopChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [TabStopChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnTextChanged(EventArgs e) {
- if (TextChanged!=null) TextChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [TextChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnValidated(EventArgs e) {
- if (Validated!=null) Validated(this, e);
+ EventHandler eh = (EventHandler)(Events [ValidatedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnValidating(System.ComponentModel.CancelEventArgs e) {
- if (Validating!=null) Validating(this, e);
+ CancelEventHandler eh = (CancelEventHandler)(Events [ValidatingEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
}
}
- if (VisibleChanged!=null) VisibleChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [VisibleChangedEvent]);
+ if (eh != null)
+ eh (this, e);
// We need to tell our kids
for (int i=0; i<child_controls.Count; i++) {
#endregion // OnXXX methods
#region Events
- public event EventHandler BackColorChanged;
- public event EventHandler BackgroundImageChanged;
- public event EventHandler BindingContextChanged;
- public event EventHandler CausesValidationChanged;
- public event UICuesEventHandler ChangeUICues;
- public event EventHandler Click;
- public event EventHandler ContextMenuChanged;
+ static object BackColorChangedEvent = new object ();
+ static object BackgroundImageChangedEvent = new object ();
+ static object BindingContextChangedEvent = new object ();
+ static object CausesValidationChangedEvent = new object ();
+ static object ChangeUICuesEvent = new object ();
+ static object ClickEvent = new object ();
+ static object ContextMenuChangedEvent = new object ();
+ static object ControlAddedEvent = new object ();
+ static object ControlRemovedEvent = new object ();
+ static object CursorChangedEvent = new object ();
+ static object DockChangedEvent = new object ();
+ static object DoubleClickEvent = new object ();
+ static object DragDropEvent = new object ();
+ static object DragEnterEvent = new object ();
+ static object DragLeaveEvent = new object ();
+ static object DragOverEvent = new object ();
+ static object EnabledChangedEvent = new object ();
+ static object EnterEvent = new object ();
+ static object FontChangedEvent = new object ();
+ static object ForeColorChangedEvent = new object ();
+ static object GiveFeedbackEvent = new object ();
+ static object GotFocusEvent = new object ();
+ static object HandleCreatedEvent = new object ();
+ static object HandleDestroyedEvent = new object ();
+ static object HelpRequestedEvent = new object ();
+ static object ImeModeChangedEvent = new object ();
+ static object InvalidatedEvent = new object ();
+ static object KeyDownEvent = new object ();
+ static object KeyPressEvent = new object ();
+ static object KeyUpEvent = new object ();
+ static object LayoutEvent = new object ();
+ static object LeaveEvent = new object ();
+ static object LocationChangedEvent = new object ();
+ static object LostFocusEvent = new object ();
+ static object MouseDownEvent = new object ();
+ static object MouseEnterEvent = new object ();
+ static object MouseHoverEvent = new object ();
+ static object MouseLeaveEvent = new object ();
+ static object MouseMoveEvent = new object ();
+ static object MouseUpEvent = new object ();
+ static object MouseWheelEvent = new object ();
+ static object MoveEvent = new object ();
+ static object PaintEvent = new object ();
+ static object ParentChangedEvent = new object ();
+ static object QueryAccessibilityHelpEvent = new object ();
+ static object QueryContinueDragEvent = new object ();
+ static object ResizeEvent = new object ();
+ static object RightToLeftChangedEvent = new object ();
+ static object SizeChangedEvent = new object ();
+ static object StyleChangedEvent = new object ();
+ static object SystemColorsChangedEvent = new object ();
+ static object TabIndexChangedEvent = new object ();
+ static object TabStopChangedEvent = new object ();
+ static object TextChangedEvent = new object ();
+ static object ValidatedEvent = new object ();
+ static object ValidatingEvent = new object ();
+ static object VisibleChangedEvent = new object ();
+
+ public event EventHandler BackColorChanged {
+ add { Events.AddHandler (BackColorChangedEvent, value); }
+ remove { Events.RemoveHandler (BackColorChangedEvent, value); }
+ }
+
+ public event EventHandler BackgroundImageChanged {
+ add { Events.AddHandler (BackgroundImageChangedEvent, value); }
+ remove { Events.RemoveHandler (BackgroundImageChangedEvent, value); }
+ }
+
+ public event EventHandler BindingContextChanged {
+ add { Events.AddHandler (BindingContextChangedEvent, value); }
+ remove { Events.RemoveHandler (BindingContextChangedEvent, value); }
+ }
+
+ public event EventHandler CausesValidationChanged {
+ add { Events.AddHandler (CausesValidationChangedEvent, value); }
+ remove { Events.RemoveHandler (CausesValidationChangedEvent, value); }
+ }
+
+ public event UICuesEventHandler ChangeUICues {
+ add { Events.AddHandler (ChangeUICuesEvent, value); }
+ remove { Events.RemoveHandler (ChangeUICuesEvent, value); }
+ }
+
+ public event EventHandler Click {
+ add { Events.AddHandler (ClickEvent, value); }
+ remove { Events.RemoveHandler (ClickEvent, value); }
+ }
+
+ public event EventHandler ContextMenuChanged {
+ add { Events.AddHandler (ContextMenuChangedEvent, value); }
+ remove { Events.RemoveHandler (ContextMenuChangedEvent, value); }
+ }
[EditorBrowsable(EditorBrowsableState.Advanced)]
[Browsable(false)]
- public event ControlEventHandler ControlAdded;
+ public event ControlEventHandler ControlAdded {
+ add { Events.AddHandler (ControlAddedEvent, value); }
+ remove { Events.RemoveHandler (ControlAddedEvent, value); }
+ }
[EditorBrowsable(EditorBrowsableState.Advanced)]
[Browsable(false)]
- public event ControlEventHandler ControlRemoved;
+ public event ControlEventHandler ControlRemoved {
+ add { Events.AddHandler (ControlRemovedEvent, value); }
+ remove { Events.RemoveHandler (ControlRemovedEvent, value); }
+ }
[MWFDescription("Fired when the cursor for the control has been changed"), MWFCategory("PropertyChanged")]
- public event EventHandler CursorChanged;
- public event EventHandler DockChanged;
- public event EventHandler DoubleClick;
- public event DragEventHandler DragDrop;
- public event DragEventHandler DragEnter;
- public event EventHandler DragLeave;
- public event DragEventHandler DragOver;
- public event EventHandler EnabledChanged;
- public event EventHandler Enter;
- public event EventHandler FontChanged;
- public event EventHandler ForeColorChanged;
- public event GiveFeedbackEventHandler GiveFeedback;
+ public event EventHandler CursorChanged {
+ add { Events.AddHandler (CursorChangedEvent, value); }
+ remove { Events.RemoveHandler (CursorChangedEvent, value); }
+ }
+ public event EventHandler DockChanged {
+ add { Events.AddHandler (DockChangedEvent, value); }
+ remove { Events.RemoveHandler (DockChangedEvent, value); }
+ }
+
+ public event EventHandler DoubleClick {
+ add { Events.AddHandler (DoubleClickEvent, value); }
+ remove { Events.RemoveHandler (DoubleClickEvent, value); }
+ }
+
+ public event DragEventHandler DragDrop {
+ add { Events.AddHandler (DragDropEvent, value); }
+ remove { Events.RemoveHandler (DragDropEvent, value); }
+ }
+
+ public event DragEventHandler DragEnter {
+ add { Events.AddHandler (DragEnterEvent, value); }
+ remove { Events.RemoveHandler (DragEnterEvent, value); }
+ }
+
+ public event EventHandler DragLeave {
+ add { Events.AddHandler (DragLeaveEvent, value); }
+ remove { Events.RemoveHandler (DragLeaveEvent, value); }
+ }
+
+ public event DragEventHandler DragOver {
+ add { Events.AddHandler (DragOverEvent, value); }
+ remove { Events.RemoveHandler (DragOverEvent, value); }
+ }
+
+ public event EventHandler EnabledChanged {
+ add { Events.AddHandler (EnabledChangedEvent, value); }
+ remove { Events.RemoveHandler (EnabledChangedEvent, value); }
+ }
+
+ public event EventHandler Enter {
+ add { Events.AddHandler (EnterEvent, value); }
+ remove { Events.RemoveHandler (EnterEvent, value); }
+ }
+
+ public event EventHandler FontChanged {
+ add { Events.AddHandler (FontChangedEvent, value); }
+ remove { Events.RemoveHandler (FontChangedEvent, value); }
+ }
+
+ public event EventHandler ForeColorChanged {
+ add { Events.AddHandler (ForeColorChangedEvent, value); }
+ remove { Events.RemoveHandler (ForeColorChangedEvent, value); }
+ }
+
+ public event GiveFeedbackEventHandler GiveFeedback {
+ add { Events.AddHandler (GiveFeedbackEvent, value); }
+ remove { Events.RemoveHandler (GiveFeedbackEvent, value); }
+ }
[EditorBrowsable(EditorBrowsableState.Advanced)]
[Browsable(false)]
- public event EventHandler GotFocus;
+ public event EventHandler GotFocus {
+ add { Events.AddHandler (GotFocusEvent, value); }
+ remove { Events.RemoveHandler (GotFocusEvent, value); }
+ }
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
[Browsable(false)]
- public event EventHandler HandleCreated;
+ public event EventHandler HandleCreated {
+ add { Events.AddHandler (HandleCreatedEvent, value); }
+ remove { Events.RemoveHandler (HandleCreatedEvent, value); }
+ }
[EditorBrowsable(EditorBrowsableState.Advanced)]
[Browsable(false)]
- public event EventHandler HandleDestroyed;
+ public event EventHandler HandleDestroyed {
+ add { Events.AddHandler (HandleDestroyedEvent, value); }
+ remove { Events.RemoveHandler (HandleDestroyedEvent, value); }
+ }
+
+ public event HelpEventHandler HelpRequested {
+ add { Events.AddHandler (HelpRequestedEvent, value); }
+ remove { Events.RemoveHandler (HelpRequestedEvent, value); }
+ }
- public event HelpEventHandler HelpRequested;
- public event EventHandler ImeModeChanged;
+ public event EventHandler ImeModeChanged {
+ add { Events.AddHandler (ImeModeChangedEvent, value); }
+ remove { Events.RemoveHandler (ImeModeChangedEvent, value); }
+ }
[EditorBrowsable(EditorBrowsableState.Advanced)]
[Browsable(false)]
- public event InvalidateEventHandler Invalidated;
+ public event InvalidateEventHandler Invalidated {
+ add { Events.AddHandler (InvalidatedEvent, value); }
+ remove { Events.RemoveHandler (InvalidatedEvent, value); }
+ }
- public event KeyEventHandler KeyDown;
- public event KeyPressEventHandler KeyPress;
- public event KeyEventHandler KeyUp;
- public event LayoutEventHandler Layout;
- public event EventHandler Leave;
- public event EventHandler LocationChanged;
+ public event KeyEventHandler KeyDown {
+ add { Events.AddHandler (KeyDownEvent, value); }
+ remove { Events.RemoveHandler (KeyDownEvent, value); }
+ }
+
+ public event KeyPressEventHandler KeyPress {
+ add { Events.AddHandler (KeyPressEvent, value); }
+ remove { Events.RemoveHandler (KeyPressEvent, value); }
+ }
+
+ public event KeyEventHandler KeyUp {
+ add { Events.AddHandler (KeyUpEvent, value); }
+ remove { Events.RemoveHandler (KeyUpEvent, value); }
+ }
+
+ public event LayoutEventHandler Layout {
+ add { Events.AddHandler (LayoutEvent, value); }
+ remove { Events.RemoveHandler (LayoutEvent, value); }
+ }
+
+ public event EventHandler Leave {
+ add { Events.AddHandler (LeaveEvent, value); }
+ remove { Events.RemoveHandler (LeaveEvent, value); }
+ }
+
+ public event EventHandler LocationChanged {
+ add { Events.AddHandler (LocationChangedEvent, value); }
+ remove { Events.RemoveHandler (LocationChangedEvent, value); }
+ }
[EditorBrowsable(EditorBrowsableState.Advanced)]
[Browsable(false)]
- public event EventHandler LostFocus;
+ public event EventHandler LostFocus {
+ add { Events.AddHandler (LostFocusEvent, value); }
+ remove { Events.RemoveHandler (LostFocusEvent, value); }
+ }
- public event MouseEventHandler MouseDown;
- public event EventHandler MouseEnter;
- public event EventHandler MouseHover;
- public event EventHandler MouseLeave;
- public event MouseEventHandler MouseMove;
- public event MouseEventHandler MouseUp;
+ public event MouseEventHandler MouseDown {
+ add { Events.AddHandler (MouseDownEvent, value); }
+ remove { Events.RemoveHandler (MouseDownEvent, value); }
+ }
+
+ public event EventHandler MouseEnter {
+ add { Events.AddHandler (MouseEnterEvent, value); }
+ remove { Events.RemoveHandler (MouseEnterEvent, value); }
+ }
+
+ public event EventHandler MouseHover {
+ add { Events.AddHandler (MouseHoverEvent, value); }
+ remove { Events.RemoveHandler (MouseHoverEvent, value); }
+ }
+
+ public event EventHandler MouseLeave {
+ add { Events.AddHandler (MouseLeaveEvent, value); }
+ remove { Events.RemoveHandler (MouseLeaveEvent, value); }
+ }
+
+ public event MouseEventHandler MouseMove {
+ add { Events.AddHandler (MouseMoveEvent, value); }
+ remove { Events.RemoveHandler (MouseMoveEvent, value); }
+ }
+
+ public event MouseEventHandler MouseUp {
+ add { Events.AddHandler (MouseUpEvent, value); }
+ remove { Events.RemoveHandler (MouseUpEvent, value); }
+ }
[EditorBrowsable(EditorBrowsableState.Advanced)]
[Browsable(false)]
- public event MouseEventHandler MouseWheel;
-
- public event EventHandler Move;
- public event PaintEventHandler Paint;
- public event EventHandler ParentChanged;
- public event QueryAccessibilityHelpEventHandler QueryAccessibilityHelp;
- public event QueryContinueDragEventHandler QueryContinueDrag;
- public event EventHandler Resize;
- public event EventHandler RightToLeftChanged;
- public event EventHandler SizeChanged;
- public event EventHandler StyleChanged;
- public event EventHandler SystemColorsChanged;
- public event EventHandler TabIndexChanged;
- public event EventHandler TabStopChanged;
- public event EventHandler TextChanged;
- public event EventHandler Validated;
- public event CancelEventHandler Validating;
- public event EventHandler VisibleChanged;
+ public event MouseEventHandler MouseWheel {
+ add { Events.AddHandler (MouseWheelEvent, value); }
+ remove { Events.RemoveHandler (MouseWheelEvent, value); }
+ }
+
+ public event EventHandler Move {
+ add { Events.AddHandler (MoveEvent, value); }
+ remove { Events.RemoveHandler (MoveEvent, value); }
+ }
+
+ public event PaintEventHandler Paint {
+ add { Events.AddHandler (PaintEvent, value); }
+ remove { Events.RemoveHandler (PaintEvent, value); }
+ }
+
+ public event EventHandler ParentChanged {
+ add { Events.AddHandler (ParentChangedEvent, value); }
+ remove { Events.RemoveHandler (ParentChangedEvent, value); }
+ }
+
+ public event QueryAccessibilityHelpEventHandler QueryAccessibilityHelp {
+ add { Events.AddHandler (QueryAccessibilityHelpEvent, value); }
+ remove { Events.RemoveHandler (QueryAccessibilityHelpEvent, value); }
+ }
+
+ public event QueryContinueDragEventHandler QueryContinueDrag {
+ add { Events.AddHandler (QueryContinueDragEvent, value); }
+ remove { Events.RemoveHandler (QueryContinueDragEvent, value); }
+ }
+
+ public event EventHandler Resize {
+ add { Events.AddHandler (ResizeEvent, value); }
+ remove { Events.RemoveHandler (ResizeEvent, value); }
+ }
+
+ public event EventHandler RightToLeftChanged {
+ add { Events.AddHandler (RightToLeftChangedEvent, value); }
+ remove { Events.RemoveHandler (RightToLeftChangedEvent, value); }
+ }
+
+ public event EventHandler SizeChanged {
+ add { Events.AddHandler (SizeChangedEvent, value); }
+ remove { Events.RemoveHandler (SizeChangedEvent, value); }
+ }
+
+ public event EventHandler StyleChanged {
+ add { Events.AddHandler (StyleChangedEvent, value); }
+ remove { Events.RemoveHandler (StyleChangedEvent, value); }
+ }
+
+ public event EventHandler SystemColorsChanged {
+ add { Events.AddHandler (SystemColorsChangedEvent, value); }
+ remove { Events.RemoveHandler (SystemColorsChangedEvent, value); }
+ }
+
+ public event EventHandler TabIndexChanged {
+ add { Events.AddHandler (TabIndexChangedEvent, value); }
+ remove { Events.RemoveHandler (TabIndexChangedEvent, value); }
+ }
+
+ public event EventHandler TabStopChanged {
+ add { Events.AddHandler (TabStopChangedEvent, value); }
+ remove { Events.RemoveHandler (TabStopChangedEvent, value); }
+ }
+
+ public event EventHandler TextChanged {
+ add { Events.AddHandler (TextChangedEvent, value); }
+ remove { Events.RemoveHandler (TextChangedEvent, value); }
+ }
+
+ public event EventHandler Validated {
+ add { Events.AddHandler (ValidatedEvent, value); }
+ remove { Events.RemoveHandler (ValidatedEvent, value); }
+ }
+
+ public event CancelEventHandler Validating {
+ add { Events.AddHandler (ValidatingEvent, value); }
+ remove { Events.RemoveHandler (ValidatingEvent, value); }
+ }
+
+ public event EventHandler VisibleChanged {
+ add { Events.AddHandler (VisibleChangedEvent, value); }
+ remove { Events.RemoveHandler (VisibleChangedEvent, value); }
+ }
+
#endregion // Events
}
}
protected virtual void OnAllowNavigationChanged (EventArgs e)
{
- if (AllowNavigationChanged != null) {
- AllowNavigationChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [AllowNavigationChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
- protected void OnBackButtonClicked (object sender, EventArgs e)
+ protected void OnBackButtonClicked (object sender, EventArgs e)
{
- if (BackButtonClick != null)
- BackButtonClick (sender, e);
+ EventHandler eh = (EventHandler)(Events [BackButtonClickEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnBackColorChanged (EventArgs e)
protected virtual void OnBackgroundColorChanged (EventArgs e)
{
- if (BackgroundColorChanged != null)
- BackgroundColorChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [BackgroundColorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnBindingContextChanged (EventArgs e)
protected virtual void OnBorderStyleChanged (EventArgs e)
{
- if (BorderStyleChanged != null)
- BorderStyleChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [BorderStyleChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnCaptionVisibleChanged (EventArgs e)
{
- if (CaptionVisibleChanged != null)
- CaptionVisibleChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [CaptionVisibleChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnCurrentCellChanged (EventArgs e)
{
- if (CurrentCellChanged != null)
- CurrentCellChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [CurrentCellChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnDataSourceChanged (EventArgs e)
{
- if (DataSourceChanged != null)
- DataSourceChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [DataSourceChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnEnter (EventArgs e)
protected virtual void OnFlatModeChanged (EventArgs e)
{
- if (FlatModeChanged != null)
- FlatModeChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [FlatModeChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnFontChanged (EventArgs e)
protected void OnNavigate (NavigateEventArgs e)
{
- if (Navigate != null)
- Navigate (this, e);
+ EventHandler eh = (EventHandler)(Events [NavigateEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnPaint (PaintEventArgs pe)
protected virtual void OnParentRowsLabelStyleChanged (EventArgs e)
{
- if (ParentRowsLabelStyleChanged != null)
- ParentRowsLabelStyleChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [ParentRowsLabelStyleChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnParentRowsVisibleChanged (EventArgs e)
{
- if (ParentRowsVisibleChanged != null)
- ParentRowsVisibleChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [ParentRowsVisibleChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnReadOnlyChanged (EventArgs e)
{
- if (ReadOnlyChanged != null)
- ReadOnlyChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [ReadOnlyChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnResize (EventArgs e)
protected void OnRowHeaderClick (EventArgs e)
{
- if (RowHeaderClick != null)
- RowHeaderClick (this, e);
+ EventHandler eh = (EventHandler)(Events [RowHeaderClickEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected void OnScroll (EventArgs e)
{
- if (Scroll != null)
- Scroll (this, e);
+ EventHandler eh = (EventHandler)(Events [ScrollEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected void OnShowParentDetailsButtonClicked (object sender, EventArgs e)
{
- if (ShowParentDetailsButtonClick != null)
- ShowParentDetailsButtonClick (sender, e);
+ EventHandler eh = (EventHandler)(Events [ShowParentDetailsButtonClickEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override bool ProcessDialogKey (Keys keyData)
#region Events
- public event EventHandler AllowNavigationChanged;
- public event EventHandler BackButtonClick;
- public event EventHandler BackgroundColorChanged;
+ static object AllowNavigationChangedEvent = new object ();
+ static object BackButtonClickEvent = new object ();
+ static object BackgroundColorChangedEvent = new object ();
+ static object BorderStyleChangedEvent = new object ();
+ static object CaptionVisibleChangedEvent = new object ();
+ static object CurrentCellChangedEvent = new object ();
+ static object DataSourceChangedEvent = new object ();
+ static object FlatModeChangedEvent = new object ();
+ static object NavigateEvent = new object ();
+ static object ParentRowsLabelStyleChangedEvent = new object ();
+ static object ParentRowsVisibleChangedEvent = new object ();
+ static object ReadOnlyChangedEvent = new object ();
+ static object RowHeaderClickEvent = new object ();
+ static object ScrollEvent = new object ();
+ static object ShowParentDetailsButtonClickEvent = new object ();
+
+ public event EventHandler AllowNavigationChanged {
+ add { Events.AddHandler (AllowNavigationChangedEvent, value); }
+ remove { Events.RemoveHandler (AllowNavigationChangedEvent, value); }
+ }
+
+ public event EventHandler BackButtonClick {
+ add { Events.AddHandler (BackButtonClickEvent, value); }
+ remove { Events.RemoveHandler (BackButtonClickEvent, value); }
+ }
+
+ public event EventHandler BackgroundColorChanged {
+ add { Events.AddHandler (BackgroundColorChangedEvent, value); }
+ remove { Events.RemoveHandler (BackgroundColorChangedEvent, value); }
+ }
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
remove { base.CursorChanged -= value; }
}
- public event EventHandler BorderStyleChanged;
- public event EventHandler CaptionVisibleChanged;
- public event EventHandler CurrentCellChanged;
- public event EventHandler DataSourceChanged;
- public event EventHandler FlatModeChanged;
- public event NavigateEventHandler Navigate;
- public event EventHandler ParentRowsLabelStyleChanged;
- public event EventHandler ParentRowsVisibleChanged;
- public event EventHandler ReadOnlyChanged;
- protected event EventHandler RowHeaderClick;
- public event EventHandler Scroll;
- public event EventHandler ShowParentDetailsButtonClick;
+ public event EventHandler BorderStyleChanged {
+ add { Events.AddHandler (BorderStyleChangedEvent, value); }
+ remove { Events.RemoveHandler (BorderStyleChangedEvent, value); }
+ }
+ public event EventHandler CaptionVisibleChanged {
+ add { Events.AddHandler (CaptionVisibleChangedEvent, value); }
+ remove { Events.RemoveHandler (CaptionVisibleChangedEvent, value); }
+ }
+
+ public event EventHandler CurrentCellChanged {
+ add { Events.AddHandler (CurrentCellChangedEvent, value); }
+ remove { Events.RemoveHandler (CurrentCellChangedEvent, value); }
+ }
+
+ public event EventHandler DataSourceChanged {
+ add { Events.AddHandler (DataSourceChangedEvent, value); }
+ remove { Events.RemoveHandler (DataSourceChangedEvent, value); }
+ }
+
+ public event EventHandler FlatModeChanged {
+ add { Events.AddHandler (FlatModeChangedEvent, value); }
+ remove { Events.RemoveHandler (FlatModeChangedEvent, value); }
+ }
+
+ public event NavigateEventHandler Navigate {
+ add { Events.AddHandler (NavigateEvent, value); }
+ remove { Events.RemoveHandler (NavigateEvent, value); }
+ }
+
+ public event EventHandler ParentRowsLabelStyleChanged {
+ add { Events.AddHandler (ParentRowsLabelStyleChangedEvent, value); }
+ remove { Events.RemoveHandler (ParentRowsLabelStyleChangedEvent, value); }
+ }
+
+ public event EventHandler ParentRowsVisibleChanged {
+ add { Events.AddHandler (ParentRowsVisibleChangedEvent, value); }
+ remove { Events.RemoveHandler (ParentRowsVisibleChangedEvent, value); }
+ }
+
+ public event EventHandler ReadOnlyChanged {
+ add { Events.AddHandler (ReadOnlyChangedEvent, value); }
+ remove { Events.RemoveHandler (ReadOnlyChangedEvent, value); }
+ }
+
+ protected event EventHandler RowHeaderClick {
+ add { Events.AddHandler (RowHeaderClickEvent, value); }
+ remove { Events.RemoveHandler (RowHeaderClickEvent, value); }
+ }
+
+ public event EventHandler Scroll {
+ add { Events.AddHandler (ScrollEvent, value); }
+ remove { Events.RemoveHandler (ScrollEvent, value); }
+ }
+
+ public event EventHandler ShowParentDetailsButtonClick {
+ add { Events.AddHandler (ShowParentDetailsButtonClickEvent, value); }
+ remove { Events.RemoveHandler (ShowParentDetailsButtonClickEvent, value); }
+ }
#endregion // Events
if (value != allownull) {
allownull = value;
- if (AllowNullChanged != null) {
- AllowNullChanged (this, EventArgs.Empty);
- }
+ EventHandler eh = (EventHandler)(Events [AllowNullChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
}
}
if (value != falsevalue) {
falsevalue = value;
- if (FalseValueChanged != null) {
- FalseValueChanged (this, EventArgs.Empty);
- }
+ EventHandler eh = (EventHandler)(Events [FalseValueChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
}
}
set {
if (value != nullvalue) {
nullvalue = value;
+
+ // XXX no NullValueChangedEvent? lame.
}
}
}
if (value != truevalue) {
truevalue = value;
- if (TrueValueChanged != null) {
- TrueValueChanged (this, EventArgs.Empty);
- }
+ EventHandler eh = (EventHandler)(Events [TrueValueChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
}
}
#endregion Private Instance Methods
#region Events
- public event EventHandler AllowNullChanged;
- public event EventHandler FalseValueChanged;
- public event EventHandler TrueValueChanged;
+ static object AllowNullChangedEvent = new object ();
+ static object FalseValueChangedEvent = new object ();
+ static object TrueValueChangedEvent = new object ();
+
+ public event EventHandler AllowNullChanged {
+ add { Events.AddHandler (AllowNullChangedEvent, value); }
+ remove { Events.RemoveHandler (AllowNullChangedEvent, value); }
+ }
+
+ public event EventHandler FalseValueChanged {
+ add { Events.AddHandler (FalseValueChangedEvent, value); }
+ remove { Events.RemoveHandler (FalseValueChangedEvent, value); }
+ }
+
+ public event EventHandler TrueValueChanged {
+ add { Events.AddHandler (TrueValueChangedEvent, value); }
+ remove { Events.RemoveHandler (TrueValueChangedEvent, value); }
+ }
#endregion // Events
}
}
table_style.DataGrid.Invalidate ();
}
- if (AlignmentChanged != null) {
- AlignmentChanged (this, EventArgs.Empty);
- }
+ EventHandler eh = (EventHandler)(Events [AlignmentChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
}
}
Invalidate ();
- if (HeaderTextChanged != null) {
- HeaderTextChanged (this, EventArgs.Empty);
- }
+ EventHandler eh = (EventHandler)(Events [HeaderTextChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
}
}
if (value != mapping_name) {
mapping_name = value;
- if (MappingNameChanged != null) {
- MappingNameChanged (this, EventArgs.Empty);
- }
+ EventHandler eh = (EventHandler)(Events [MappingNameChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
}
}
table_style.DataGrid.Invalidate ();
}
- if (NullTextChanged != null) {
- NullTextChanged (this, EventArgs.Empty);
- }
+ EventHandler eh = (EventHandler)(Events [NullTextChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
}
}
if (value != property_descriptor) {
property_descriptor = value;
- if (PropertyDescriptorChanged != null) {
- PropertyDescriptorChanged (this, EventArgs.Empty);
- }
+ EventHandler eh = (EventHandler)(Events [PropertyDescriptorChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
}
}
table_style.DataGrid.CalcAreasAndInvalidate ();
}
- if (ReadOnlyChanged != null) {
- ReadOnlyChanged (this, EventArgs.Empty);
- }
+ EventHandler eh = (EventHandler)(Events [ReadOnlyChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
}
}
table_style.DataGrid.CalcAreasAndInvalidate ();
}
- if (WidthChanged != null) {
- WidthChanged (this, EventArgs.Empty);
- }
+ EventHandler eh = (EventHandler)(Events [WidthChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
}
}
#region Events
- public event EventHandler AlignmentChanged;
- public event EventHandler FontChanged;
- public event EventHandler HeaderTextChanged;
- public event EventHandler MappingNameChanged;
- public event EventHandler NullTextChanged;
+ static object AlignmentChangedEvent = new object ();
+ static object FontChangedEvent = new object ();
+ static object HeaderTextChangedEvent = new object ();
+ static object MappingNameChangedEvent = new object ();
+ static object NullTextChangedEvent = new object ();
+ static object PropertyDescriptorChangedEvent = new object ();
+ static object ReadOnlyChangedEvent = new object ();
+ static object WidthChangedEvent = new object ();
+
+ public event EventHandler AlignmentChanged {
+ add { Events.AddHandler (AlignmentChangedEvent, value); }
+ remove { Events.RemoveHandler (AlignmentChangedEvent, value); }
+ }
+
+ public event EventHandler FontChanged {
+ add { Events.AddHandler (FontChangedEvent, value); }
+ remove { Events.RemoveHandler (FontChangedEvent, value); }
+ }
+
+ public event EventHandler HeaderTextChanged {
+ add { Events.AddHandler (HeaderTextChangedEvent, value); }
+ remove { Events.RemoveHandler (HeaderTextChangedEvent, value); }
+ }
+
+ public event EventHandler MappingNameChanged {
+ add { Events.AddHandler (MappingNameChangedEvent, value); }
+ remove { Events.RemoveHandler (MappingNameChangedEvent, value); }
+ }
+
+ public event EventHandler NullTextChanged {
+ add { Events.AddHandler (NullTextChangedEvent, value); }
+ remove { Events.RemoveHandler (NullTextChangedEvent, value); }
+ }
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
- public event EventHandler PropertyDescriptorChanged;
- public event EventHandler ReadOnlyChanged;
- public event EventHandler WidthChanged;
+ public event EventHandler PropertyDescriptorChanged {
+ add { Events.AddHandler (PropertyDescriptorChangedEvent, value); }
+ remove { Events.RemoveHandler (PropertyDescriptorChangedEvent, value); }
+ }
+
+ public event EventHandler ReadOnlyChanged {
+ add { Events.AddHandler (ReadOnlyChangedEvent, value); }
+ remove { Events.RemoveHandler (ReadOnlyChangedEvent, value); }
+ }
+
+ public event EventHandler WidthChanged {
+ add { Events.AddHandler (WidthChangedEvent, value); }
+ remove { Events.RemoveHandler (WidthChangedEvent, value); }
+ }
#endregion // Events
}
}
protected virtual void OnAllowSortingChanged (EventArgs e)
{
- if (AllowSortingChanged != null) {
- AllowSortingChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [AllowSortingChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnAlternatingBackColorChanged (EventArgs e)
{
- if (AlternatingBackColorChanged != null) {
- AlternatingBackColorChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [AlternatingBackColorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnBackColorChanged (EventArgs e)
{
- if (BackColorChanged != null) {
- BackColorChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [BackColorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnColumnHeadersVisibleChanged (EventArgs e)
{
- if (ColumnHeadersVisibleChanged != null) {
- ColumnHeadersVisibleChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [ColumnHeadersVisibleChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnForeColorChanged (EventArgs e)
{
- if (ForeColorChanged != null) {
- ForeColorChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [ForeColorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnGridLineColorChanged (EventArgs e)
{
- if (GridLineColorChanged != null) {
- GridLineColorChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [GridLineColorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnGridLineStyleChanged (EventArgs e)
{
- if (GridLineStyleChanged != null) {
- GridLineStyleChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [GridLineStyleChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnHeaderBackColorChanged (EventArgs e)
{
- if (HeaderBackColorChanged != null) {
- HeaderBackColorChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [HeaderBackColorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnHeaderFontChanged (EventArgs e)
{
- if (HeaderFontChanged != null) {
- HeaderFontChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [HeaderFontChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnHeaderForeColorChanged (EventArgs e)
{
- if (HeaderForeColorChanged != null) {
- HeaderForeColorChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [HeaderForeColorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnLinkColorChanged (EventArgs e)
{
- if (LinkColorChanged != null) {
- LinkColorChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [LinkColorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnLinkHoverColorChanged (EventArgs e)
{
- if (LinkHoverColorChanged != null) {
- LinkHoverColorChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [LinkHoverColorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnMappingNameChanged (EventArgs e)
{
- if (MappingNameChanged != null) {
- MappingNameChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [MappingNameChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnPreferredColumnWidthChanged (EventArgs e)
{
- if (PreferredColumnWidthChanged != null) {
- PreferredColumnWidthChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [PreferredColumnWidthChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnPreferredRowHeightChanged (EventArgs e)
{
- if (PreferredRowHeightChanged != null) {
- PreferredRowHeightChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [PreferredRowHeightChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnReadOnlyChanged (EventArgs e)
{
- if (ReadOnlyChanged != null) {
- ReadOnlyChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [ReadOnlyChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnRowHeadersVisibleChanged (EventArgs e)
{
- if (RowHeadersVisibleChanged != null) {
- RowHeadersVisibleChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [RowHeadersVisibleChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnRowHeaderWidthChanged (EventArgs e)
{
- if (RowHeaderWidthChanged != null) {
- RowHeaderWidthChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [RowHeaderWidthChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnSelectionBackColorChanged (EventArgs e)
{
- if (SelectionBackColorChanged != null) {
- SelectionBackColorChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [SelectionBackColorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnSelectionForeColorChanged (EventArgs e)
{
- if (SelectionForeColorChanged != null) {
- SelectionForeColorChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [SelectionForeColorChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
public void ResetAlternatingBackColor ()
#endregion Private Instance Properties
#region Events
- public event EventHandler AllowSortingChanged;
- public event EventHandler AlternatingBackColorChanged;
- public event EventHandler BackColorChanged;
- public event EventHandler ColumnHeadersVisibleChanged;
- public event EventHandler ForeColorChanged;
- public event EventHandler GridLineColorChanged;
- public event EventHandler GridLineStyleChanged;
- public event EventHandler HeaderBackColorChanged;
- public event EventHandler HeaderFontChanged;
- public event EventHandler HeaderForeColorChanged;
- public event EventHandler LinkColorChanged;
- public event EventHandler LinkHoverColorChanged;
- public event EventHandler MappingNameChanged;
- public event EventHandler PreferredColumnWidthChanged;
- public event EventHandler PreferredRowHeightChanged;
- public event EventHandler ReadOnlyChanged;
- public event EventHandler RowHeadersVisibleChanged;
- public event EventHandler RowHeaderWidthChanged;
- public event EventHandler SelectionBackColorChanged;
- public event EventHandler SelectionForeColorChanged;
+ static object AllowSortingChangedEvent = new object ();
+ static object AlternatingBackColorChangedEvent = new object ();
+ static object BackColorChangedEvent = new object ();
+ static object ColumnHeadersVisibleChangedEvent = new object ();
+ static object ForeColorChangedEvent = new object ();
+ static object GridLineColorChangedEvent = new object ();
+ static object GridLineStyleChangedEvent = new object ();
+ static object HeaderBackColorChangedEvent = new object ();
+ static object HeaderFontChangedEvent = new object ();
+ static object HeaderForeColorChangedEvent = new object ();
+ static object LinkColorChangedEvent = new object ();
+ static object LinkHoverColorChangedEvent = new object ();
+ static object MappingNameChangedEvent = new object ();
+ static object PreferredColumnWidthChangedEvent = new object ();
+ static object PreferredRowHeightChangedEvent = new object ();
+ static object ReadOnlyChangedEvent = new object ();
+ static object RowHeadersVisibleChangedEvent = new object ();
+ static object RowHeaderWidthChangedEvent = new object ();
+ static object SelectionBackColorChangedEvent = new object ();
+ static object SelectionForeColorChangedEvent = new object ();
+
+ public event EventHandler AllowSortingChanged {
+ add { Events.AddHandler (AllowSortingChangedEvent, value); }
+ remove { Events.RemoveHandler (AllowSortingChangedEvent, value); }
+ }
+
+ public event EventHandler AlternatingBackColorChanged {
+ add { Events.AddHandler (AlternatingBackColorChangedEvent, value); }
+ remove { Events.RemoveHandler (AlternatingBackColorChangedEvent, value); }
+ }
+
+ public event EventHandler BackColorChanged {
+ add { Events.AddHandler (BackColorChangedEvent, value); }
+ remove { Events.RemoveHandler (BackColorChangedEvent, value); }
+ }
+
+ public event EventHandler ColumnHeadersVisibleChanged {
+ add { Events.AddHandler (ColumnHeadersVisibleChangedEvent, value); }
+ remove { Events.RemoveHandler (ColumnHeadersVisibleChangedEvent, value); }
+ }
+
+ public event EventHandler ForeColorChanged {
+ add { Events.AddHandler (ForeColorChangedEvent, value); }
+ remove { Events.RemoveHandler (ForeColorChangedEvent, value); }
+ }
+
+ public event EventHandler GridLineColorChanged {
+ add { Events.AddHandler (GridLineColorChangedEvent, value); }
+ remove { Events.RemoveHandler (GridLineColorChangedEvent, value); }
+ }
+
+ public event EventHandler GridLineStyleChanged {
+ add { Events.AddHandler (GridLineStyleChangedEvent, value); }
+ remove { Events.RemoveHandler (GridLineStyleChangedEvent, value); }
+ }
+
+ public event EventHandler HeaderBackColorChanged {
+ add { Events.AddHandler (HeaderBackColorChangedEvent, value); }
+ remove { Events.RemoveHandler (HeaderBackColorChangedEvent, value); }
+ }
+
+ public event EventHandler HeaderFontChanged {
+ add { Events.AddHandler (HeaderFontChangedEvent, value); }
+ remove { Events.RemoveHandler (HeaderFontChangedEvent, value); }
+ }
+
+ public event EventHandler HeaderForeColorChanged {
+ add { Events.AddHandler (HeaderForeColorChangedEvent, value); }
+ remove { Events.RemoveHandler (HeaderForeColorChangedEvent, value); }
+ }
+
+ public event EventHandler LinkColorChanged {
+ add { Events.AddHandler (LinkColorChangedEvent, value); }
+ remove { Events.RemoveHandler (LinkColorChangedEvent, value); }
+ }
+
+ public event EventHandler LinkHoverColorChanged {
+ add { Events.AddHandler (LinkHoverColorChangedEvent, value); }
+ remove { Events.RemoveHandler (LinkHoverColorChangedEvent, value); }
+ }
+
+ public event EventHandler MappingNameChanged {
+ add { Events.AddHandler (MappingNameChangedEvent, value); }
+ remove { Events.RemoveHandler (MappingNameChangedEvent, value); }
+ }
+
+ public event EventHandler PreferredColumnWidthChanged {
+ add { Events.AddHandler (PreferredColumnWidthChangedEvent, value); }
+ remove { Events.RemoveHandler (PreferredColumnWidthChangedEvent, value); }
+ }
+
+ public event EventHandler PreferredRowHeightChanged {
+ add { Events.AddHandler (PreferredRowHeightChangedEvent, value); }
+ remove { Events.RemoveHandler (PreferredRowHeightChangedEvent, value); }
+ }
+
+ public event EventHandler ReadOnlyChanged {
+ add { Events.AddHandler (ReadOnlyChangedEvent, value); }
+ remove { Events.RemoveHandler (ReadOnlyChangedEvent, value); }
+ }
+
+ public event EventHandler RowHeadersVisibleChanged {
+ add { Events.AddHandler (RowHeadersVisibleChangedEvent, value); }
+ remove { Events.RemoveHandler (RowHeadersVisibleChangedEvent, value); }
+ }
+
+ public event EventHandler RowHeaderWidthChanged {
+ add { Events.AddHandler (RowHeaderWidthChangedEvent, value); }
+ remove { Events.RemoveHandler (RowHeaderWidthChangedEvent, value); }
+ }
+
+ public event EventHandler SelectionBackColorChanged {
+ add { Events.AddHandler (SelectionBackColorChangedEvent, value); }
+ remove { Events.RemoveHandler (SelectionBackColorChangedEvent, value); }
+ }
+
+ public event EventHandler SelectionForeColorChanged {
+ add { Events.AddHandler (SelectionForeColorChangedEvent, value); }
+ remove { Events.RemoveHandler (SelectionForeColorChangedEvent, value); }
+ }
#endregion // Events
}
}
#endregion // public methods
#region public events
-
+ static object CloseUpEvent = new object ();
+ static object DropDownEvent = new object ();
+ static object FormatChangedEvent = new object ();
+ static object ValueChangedEvent = new object ();
+
// raised when the monthcalendar is closed
- public event EventHandler CloseUp;
+ public event EventHandler CloseUp {
+ add { Events.AddHandler (CloseUpEvent, value); }
+ remove { Events.RemoveHandler (CloseUpEvent, value); }
+ }
// raised when the monthcalendar is opened
- public event EventHandler DropDown;
+ public event EventHandler DropDown {
+ add { Events.AddHandler (DropDownEvent, value); }
+ remove { Events.RemoveHandler (DropDownEvent, value); }
+ }
// raised when the format of the value is changed
- public event EventHandler FormatChanged;
+ public event EventHandler FormatChanged {
+ add { Events.AddHandler (FormatChangedEvent, value); }
+ remove { Events.RemoveHandler (FormatChangedEvent, value); }
+ }
// raised when the date Value is changed
- public event EventHandler ValueChanged;
+ public event EventHandler ValueChanged {
+ add { Events.AddHandler (ValueChangedEvent, value); }
+ remove { Events.RemoveHandler (ValueChangedEvent, value); }
+ }
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
// raises the CloseUp event
protected virtual void OnCloseUp (EventArgs eventargs) {
- if (this.CloseUp != null) {
- this.CloseUp (this, eventargs);
- }
+ EventHandler eh = (EventHandler)(Events [CloseUpEvent]);
+ if (eh != null)
+ eh (this, eventargs);
}
// raise the drop down event
protected virtual void OnDropDown (EventArgs eventargs) {
- if (this.DropDown != null) {
- this.DropDown (this, eventargs);
- }
+ EventHandler eh = (EventHandler)(Events [DropDownEvent]);
+ if (eh != null)
+ eh (this, eventargs);
}
protected override void OnFontChanged(EventArgs e) {
// raises the format changed event
protected virtual void OnFormatChanged (EventArgs e) {
- if (this.FormatChanged != null) {
- this.FormatChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [FormatChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
// not sure why we're overriding this one
// raise the ValueChanged event
protected virtual void OnValueChanged (EventArgs eventargs) {
- if (this.ValueChanged != null) {
- this.ValueChanged (this, eventargs);
- }
+ EventHandler eh = (EventHandler)(Events [ValueChangedEvent]);
+ if (eh != null)
+ eh (this, eventargs);
}
// overridden to set the bounds of this control properly
month_calendar.Focus ();
// fire any registered events
- if (this.DropDown != null) {
- this.DropDown (this, EventArgs.Empty);
- }
+ // XXX should this just call OnDropDown?
+ EventHandler eh = (EventHandler)(Events [DropDownEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
// hide the month calendar
}
protected void OnSelectedItemChanged(object source, EventArgs e) {
- EventHandler handler = SelectedItemChanged;
-
- if (handler != null)
- handler(source, e);
+ EventHandler eh = (EventHandler)(Events [SelectedItemChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void UpdateEditText() {
#endregion // Protected Instance Methods
#region Events
- public event EventHandler SelectedItemChanged;
+ static object SelectedItemChangedEvent = new object ();
+ public event EventHandler SelectedItemChanged {
+ add { Events.AddHandler (SelectedItemChangedEvent, value); }
+ remove { Events.RemoveHandler (SelectedItemChangedEvent, value); }
+ }
#endregion // Events
}
}
#endregion // Internal Methods
#region Events
+ static object HelpRequestEvent = new object ();
+
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
- public event EventHandler HelpRequest;
+ public event EventHandler HelpRequest {
+ add { Events.AddHandler (HelpRequestEvent, value); }
+ remove { Events.RemoveHandler (HelpRequestEvent, value); }
+ }
#endregion
internal class FolderBrowserTreeView : TreeView
if (is_loaded)
SelectActiveControl ();
- if (Activated != null) {
- Activated(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [ActivatedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnClosed(EventArgs e) {
- if (Closed != null) {
- Closed(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [ClosedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnClosing(System.ComponentModel.CancelEventArgs e) {
- if (Closing != null) {
- Closing(this, e);
- }
+ CancelEventHandler eh = (CancelEventHandler)(Events [ClosingEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnDeactivate(EventArgs e) {
- if (Deactivate != null) {
- Deactivate(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [DeactivateEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnInputLanguageChanged(InputLanguageChangedEventArgs e) {
- if (InputLanguageChanged!=null) {
- InputLanguageChanged(this, e);
- }
+ InputLanguageChangedEventHandler eh = (InputLanguageChangedEventHandler)(Events [InputLanguageChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnInputLanguageChanging(InputLanguageChangingEventArgs e) {
- if (InputLanguageChanging!=null) {
- InputLanguageChanging(this, e);
- }
+ InputLanguageChangingEventHandler eh = (InputLanguageChangingEventHandler)(Events [InputLanguageChangingEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
AutoScale = false;
}
- if (Load != null) {
- Load(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [LoadEvent]);
+ if (eh != null)
+ eh (this, e);
if (!IsMdiChild) {
switch (StartPosition) {
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMaximizedBoundsChanged(EventArgs e) {
- if (MaximizedBoundsChanged != null) {
- MaximizedBoundsChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [MaximizedBoundsChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMaximumSizeChanged(EventArgs e) {
- if (MaximumSizeChanged != null) {
- MaximumSizeChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [MaximumSizeChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMdiChildActivate(EventArgs e) {
- if (MdiChildActivate != null) {
- MdiChildActivate(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [MdiChildActivateEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMenuComplete(EventArgs e) {
- if (MenuComplete != null) {
- MenuComplete(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [MenuCompleteEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMenuStart(EventArgs e) {
- if (MenuStart != null) {
- MenuStart(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [MenuStartEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMinimumSizeChanged(EventArgs e) {
- if (MinimumSizeChanged != null) {
- MinimumSizeChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [MinimumSizeChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
}
#region Events
- public event EventHandler Activated;
- public event EventHandler Closed;
- public event CancelEventHandler Closing;
- public event EventHandler Deactivate;
- public event InputLanguageChangedEventHandler InputLanguageChanged;
- public event InputLanguageChangingEventHandler InputLanguageChanging;
- public event EventHandler Load;
- public event EventHandler MaximizedBoundsChanged;
- public event EventHandler MaximumSizeChanged;
- public event EventHandler MdiChildActivate;
- public event EventHandler MenuComplete;
- public event EventHandler MenuStart;
- public event EventHandler MinimumSizeChanged;
+ static object ActivatedEvent = new object ();
+ static object ClosedEvent = new object ();
+ static object ClosingEvent = new object ();
+ static object DeactivateEvent = new object ();
+ static object InputLanguageChangedEvent = new object ();
+ static object InputLanguageChangingEvent = new object ();
+ static object LoadEvent = new object ();
+ static object MaximizedBoundsChangedEvent = new object ();
+ static object MaximumSizeChangedEvent = new object ();
+ static object MdiChildActivateEvent = new object ();
+ static object MenuCompleteEvent = new object ();
+ static object MenuStartEvent = new object ();
+ static object MinimumSizeChangedEvent = new object ();
+
+ public event EventHandler Activated {
+ add { Events.AddHandler (ActivatedEvent, value); }
+ remove { Events.RemoveHandler (ActivatedEvent, value); }
+ }
+
+ public event EventHandler Closed {
+ add { Events.AddHandler (ClosedEvent, value); }
+ remove { Events.RemoveHandler (ClosedEvent, value); }
+ }
+
+ public event CancelEventHandler Closing {
+ add { Events.AddHandler (ClosingEvent, value); }
+ remove { Events.RemoveHandler (ClosingEvent, value); }
+ }
+
+ public event EventHandler Deactivate {
+ add { Events.AddHandler (DeactivateEvent, value); }
+ remove { Events.RemoveHandler (DeactivateEvent, value); }
+ }
+
+ public event InputLanguageChangedEventHandler InputLanguageChanged {
+ add { Events.AddHandler (InputLanguageChangedEvent, value); }
+ remove { Events.RemoveHandler (InputLanguageChangedEvent, value); }
+ }
+
+ public event InputLanguageChangingEventHandler InputLanguageChanging {
+ add { Events.AddHandler (InputLanguageChangingEvent, value); }
+ remove { Events.RemoveHandler (InputLanguageChangingEvent, value); }
+ }
+
+ public event EventHandler Load {
+ add { Events.AddHandler (LoadEvent, value); }
+ remove { Events.RemoveHandler (LoadEvent, value); }
+ }
+
+ public event EventHandler MaximizedBoundsChanged {
+ add { Events.AddHandler (MaximizedBoundsChangedEvent, value); }
+ remove { Events.RemoveHandler (MaximizedBoundsChangedEvent, value); }
+ }
+
+ public event EventHandler MaximumSizeChanged {
+ add { Events.AddHandler (MaximumSizeChangedEvent, value); }
+ remove { Events.RemoveHandler (MaximumSizeChangedEvent, value); }
+ }
+
+ public event EventHandler MdiChildActivate {
+ add { Events.AddHandler (MdiChildActivateEvent, value); }
+ remove { Events.RemoveHandler (MdiChildActivateEvent, value); }
+ }
+
+ public event EventHandler MenuComplete {
+ add { Events.AddHandler (MenuCompleteEvent, value); }
+ remove { Events.RemoveHandler (MenuCompleteEvent, value); }
+ }
+
+ public event EventHandler MenuStart {
+ add { Events.AddHandler (MenuStartEvent, value); }
+ remove { Events.RemoveHandler (MenuStartEvent, value); }
+ }
+
+ public event EventHandler MinimumSizeChanged {
+ add { Events.AddHandler (MinimumSizeChangedEvent, value); }
+ remove { Events.RemoveHandler (MinimumSizeChangedEvent, value); }
+ }
+
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
}
}
- public event FormClosingEventHandler FormClosing;
- public event FormClosedEventHandler FormClosed;
+ static object FormClosingEvent = new object ();
+ static object FormClosedEvent = new object ();
+
+ public event FormClosingEventHandler FormClosing {
+ add { Events.AddHandler (FormClosingEvent, value); }
+ remove { Events.RemoveHandler (FormClosingEvent, value); }
+ }
+
+ public event FormClosedEventHandler FormClosed {
+ add { Events.AddHandler (FormClosedEvent, value); }
+ remove { Events.RemoveHandler (FormClosedEvent, value); }
+ }
protected virtual void OnFormClosing (FormClosingEventArgs e)
{
- if (FormClosing != null)
- FormClosing (this, e);
+ FormClosingEventHandler eh = (FormClosingEventHandler)(Events [FormClosingEvent]);
+ if (eh != null)
+ eh (this, e);
}
#endif
}
#if NET_2_0
private object tag;
#endif
- private EventHandler recreateHandle;
private readonly ImageCollection images;
#endregion // Private Fields
#region Private Instance Methods
private void OnRecreateHandle()
{
- if (this.recreateHandle != null)
- this.recreateHandle(this, EventArgs.Empty);
+ EventHandler eh = (EventHandler)(Events [RecreateHandleEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
#if NET_2_0
#endregion // Protected Instance Methods
#region Events
+ static object RecreateHandleEvent = new object ();
+
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
public event EventHandler RecreateHandle {
- add {
- this.recreateHandle += value;
- }
-
- remove {
- this.recreateHandle -= value;
- }
+ add { Events.AddHandler (RecreateHandleEvent, value); }
+ remove { Events.RemoveHandler (RecreateHandleEvent, value); }
}
#endregion // Events
}
static SizeF req_witdthsize = new SizeF (0,0);
#region Events
- public event EventHandler AutoSizeChanged;
+ static object AutoSizeChangedEvent = new object ();
+ static object TextAlignChangedEvent = new object ();
+
+ public event EventHandler AutoSizeChanged {
+ add { Events.AddHandler (AutoSizeChangedEvent, value); }
+ remove { Events.RemoveHandler (AutoSizeChangedEvent, value); }
+ }
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
}
}
- public event EventHandler TextAlignChanged;
+ public event EventHandler TextAlignChanged {
+ add { Events.AddHandler (TextAlignChangedEvent, value); }
+ remove { Events.RemoveHandler (TextAlignChangedEvent, value); }
+ }
#endregion
public Label ()
CalcPreferredHeight ();
CalcPreferredWidth ();
- AutoSizeChanged = null;
- TextAlignChanged = null;
-
SetStyle (ControlStyles.Selectable, false);
SetStyle (ControlStyles.ResizeRedraw |
ControlStyles.UserPaint |
protected virtual void OnAutoSizeChanged (EventArgs e)
{
- if (AutoSizeChanged != null)
- AutoSizeChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [AutoSizeChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnEnabledChanged (EventArgs e)
protected virtual void OnTextAlignChanged (EventArgs e)
{
- if (TextAlignChanged != null)
- TextAlignChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [TextAlignChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnTextChanged (EventArgs e)
private int focused_index;
#region Events
- public event LinkLabelLinkClickedEventHandler LinkClicked;
+ static object LinkClickedEvent = new object ();
+
+ public event LinkLabelLinkClickedEventHandler LinkClicked {
+ add { Events.AddHandler (LinkClickedEvent, value); }
+ remove { Events.RemoveHandler (LinkClickedEvent, value); }
+ }
#endregion // Events
public LinkLabel ()
protected virtual void OnLinkClicked (LinkLabelLinkClickedEventArgs e)
{
- if (LinkClicked != null)
- LinkClicked (this, e);
+ LinkLabelLinkClickedEventHandler eh = (LinkLabelLinkClickedEventHandler)(Events [LinkClickedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnLostFocus (EventArgs e)
}
#region Events
+ static object DrawItemEvent = new object ();
+ static object MeasureItemEvent = new object ();
+ static object SelectedIndexChangedEvent = new object ();
+
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
public new event EventHandler BackgroundImageChanged {
remove { base.Click -= value; }
}
- public event DrawItemEventHandler DrawItem;
- public event MeasureItemEventHandler MeasureItem;
+ public event DrawItemEventHandler DrawItem {
+ add { Events.AddHandler (DrawItemEvent, value); }
+ remove { Events.RemoveHandler (DrawItemEvent, value); }
+ }
+
+ public event MeasureItemEventHandler MeasureItem {
+ add { Events.AddHandler (MeasureItemEvent, value); }
+ remove { Events.RemoveHandler (MeasureItemEvent, value); }
+ }
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
remove { base.Paint -= value; }
}
- public event EventHandler SelectedIndexChanged;
+ public event EventHandler SelectedIndexChanged {
+ add { Events.AddHandler (SelectedIndexChangedEvent, value); }
+ remove { Events.RemoveHandler (SelectedIndexChangedEvent, value); }
+ }
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Advanced)]
switch (DrawMode) {
case DrawMode.OwnerDrawFixed:
case DrawMode.OwnerDrawVariable:
- if (DrawItem != null)
- DrawItem (this, e);
+ DrawItemEventHandler eh = (DrawItemEventHandler)(Events [DrawItemEvent]);
+ if (eh != null)
+ eh (this, e);
+
break;
default:
{
if (draw_mode != DrawMode.OwnerDrawVariable)
return;
-
- if (MeasureItem != null)
- MeasureItem (this, e);
+
+ MeasureItemEventHandler eh = (MeasureItemEventHandler)(Events [MeasureItemEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnParentChanged (EventArgs e)
{
base.OnSelectedIndexChanged (e);
- if (SelectedIndexChanged != null)
- SelectedIndexChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [SelectedIndexChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnSelectedValueChanged (EventArgs e)
}
#region Events
- public event EventHandler DataSourceChanged;
- public event EventHandler DisplayMemberChanged;
- public event EventHandler SelectedValueChanged;
- public event EventHandler ValueMemberChanged;
+ static object DataSourceChangedEvent = new object ();
+ static object DisplayMemberChangedEvent = new object ();
+ static object SelectedValueChangedEvent = new object ();
+ static object ValueMemberChangedEvent = new object ();
+
+ public event EventHandler DataSourceChanged {
+ add { Events.AddHandler (DataSourceChangedEvent, value); }
+ remove { Events.RemoveHandler (DataSourceChangedEvent, value); }
+ }
+
+ public event EventHandler DisplayMemberChanged {
+ add { Events.AddHandler (DisplayMemberChangedEvent, value); }
+ remove { Events.RemoveHandler (DisplayMemberChangedEvent, value); }
+ }
+
+ public event EventHandler SelectedValueChanged {
+ add { Events.AddHandler (SelectedValueChangedEvent, value); }
+ remove { Events.RemoveHandler (SelectedValueChangedEvent, value); }
+ }
+
+ public event EventHandler ValueMemberChanged {
+ add { Events.AddHandler (ValueMemberChangedEvent, value); }
+ remove { Events.RemoveHandler (ValueMemberChangedEvent, value); }
+ }
+
#endregion // Events
#region .NET 2.0 Public Properties
protected virtual void OnDataSourceChanged (EventArgs e)
{
- if (DataSourceChanged != null)
- DataSourceChanged (this,e);
+ EventHandler eh = (EventHandler)(Events [DataSourceChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnDisplayMemberChanged (EventArgs e)
{
- if (DisplayMemberChanged != null)
- DisplayMemberChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [DisplayMemberChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnSelectedIndexChanged (EventArgs e)
protected virtual void OnSelectedValueChanged (EventArgs e)
{
- if (SelectedValueChanged != null)
- SelectedValueChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [SelectedValueChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnValueMemberChanged (EventArgs e)
{
- if (ValueMemberChanged != null)
- ValueMemberChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [ValueMemberChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected abstract void RefreshItem (int index);
internal Size text_size = Size.Empty;
#region Events
- public event LabelEditEventHandler AfterLabelEdit;
+ static object AfterLabelEditEvent = new object ();
+ static object BeforeLabelEditEvent = new object ();
+ static object ColumnClickEvent = new object ();
+ static object ItemActivateEvent = new object ();
+ static object ItemCheckEvent = new object ();
+ static object ItemDragEvent = new object ();
+ static object SelectedIndexChangedEvent = new object ();
+
+ public event LabelEditEventHandler AfterLabelEdit {
+ add { Events.AddHandler (AfterLabelEditEvent, value); }
+ remove { Events.RemoveHandler (AfterLabelEditEvent, value); }
+ }
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
remove { base.BackgroundImageChanged -= value; }
}
- public event LabelEditEventHandler BeforeLabelEdit;
- public event ColumnClickEventHandler ColumnClick;
- public event EventHandler ItemActivate;
- public event ItemCheckEventHandler ItemCheck;
- public event ItemDragEventHandler ItemDrag;
+ public event LabelEditEventHandler BeforeLabelEdit {
+ add { Events.AddHandler (BeforeLabelEditEvent, value); }
+ remove { Events.RemoveHandler (BeforeLabelEditEvent, value); }
+ }
+
+ public event ColumnClickEventHandler ColumnClick {
+ add { Events.AddHandler (ColumnClickEvent, value); }
+ remove { Events.RemoveHandler (ColumnClickEvent, value); }
+ }
+
+ public event EventHandler ItemActivate {
+ add { Events.AddHandler (ItemActivateEvent, value); }
+ remove { Events.RemoveHandler (ItemActivateEvent, value); }
+ }
+
+ public event ItemCheckEventHandler ItemCheck {
+ add { Events.AddHandler (ItemCheckEvent, value); }
+ remove { Events.RemoveHandler (ItemCheckEvent, value); }
+ }
+
+ public event ItemDragEventHandler ItemDrag {
+ add { Events.AddHandler (ItemDragEvent, value); }
+ remove { Events.RemoveHandler (ItemDragEvent, value); }
+ }
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
remove { base.Paint -= value; }
}
- public event EventHandler SelectedIndexChanged;
+ public event EventHandler SelectedIndexChanged {
+ add { Events.AddHandler (SelectedIndexChangedEvent, value); }
+ remove { Events.RemoveHandler (SelectedIndexChangedEvent, value); }
+ }
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
void ItemsDoubleClick (object sender, EventArgs e)
{
- if (owner.activation == ItemActivation.Standard && owner.ItemActivate != null)
- owner.ItemActivate (this, e);
+ if (owner.activation == ItemActivation.Standard)
+ owner.OnItemActivate (EventArgs.Empty);
}
enum BoxSelect {
protected virtual void OnAfterLabelEdit (LabelEditEventArgs e)
{
- if (AfterLabelEdit != null)
- AfterLabelEdit (this, e);
+ LabelEditEventHandler eh = (LabelEditEventHandler)(Events [AfterLabelEditEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnBeforeLabelEdit (LabelEditEventArgs e)
{
- if (BeforeLabelEdit != null)
- BeforeLabelEdit (this, e);
+ LabelEditEventHandler eh = (LabelEditEventHandler)(Events [BeforeLabelEditEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnColumnClick (ColumnClickEventArgs e)
{
- if (ColumnClick != null)
- ColumnClick (this, e);
+ ColumnClickEventHandler eh = (ColumnClickEventHandler)(Events [ColumnClickEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnEnabledChanged (EventArgs e)
protected virtual void OnItemActivate (EventArgs e)
{
- if (ItemActivate != null)
- ItemActivate (this, e);
+ EventHandler eh = (EventHandler)(Events [ItemActivateEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnItemCheck (ItemCheckEventArgs ice)
{
- if (ItemCheck != null)
- ItemCheck (this, ice);
+ EventHandler eh = (EventHandler)(Events [ItemCheckEvent]);
+ if (eh != null)
+ eh (this, ice);
}
protected virtual void OnItemDrag (ItemDragEventArgs e)
{
- if (ItemDrag != null)
- ItemDrag (this, e);
+ EventHandler eh = (EventHandler)(Events [ItemDragEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnSelectedIndexChanged (EventArgs e)
{
- if (SelectedIndexChanged != null)
- SelectedIndexChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [SelectedIndexChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnSystemColorsChanged (EventArgs e)
}
#region Events
- public event EventHandler Click;
- public event DrawItemEventHandler DrawItem;
- public event MeasureItemEventHandler MeasureItem;
- public event EventHandler Popup;
- public event EventHandler Select;
+ static object ClickEvent = new object ();
+ static object DrawItemEvent = new object ();
+ static object MeasureItemEvent = new object ();
+ static object PopupEvent = new object ();
+ static object SelectEvent = new object ();
+
+ public event EventHandler Click {
+ add { Events.AddHandler (ClickEvent, value); }
+ remove { Events.RemoveHandler (ClickEvent, value); }
+ }
+
+ public event DrawItemEventHandler DrawItem {
+ add { Events.AddHandler (DrawItemEvent, value); }
+ remove { Events.RemoveHandler (DrawItemEvent, value); }
+ }
+
+ public event MeasureItemEventHandler MeasureItem {
+ add { Events.AddHandler (MeasureItemEvent, value); }
+ remove { Events.RemoveHandler (MeasureItemEvent, value); }
+ }
+
+ public event EventHandler Popup {
+ add { Events.AddHandler (PopupEvent, value); }
+ remove { Events.RemoveHandler (PopupEvent, value); }
+ }
+
+ public event EventHandler Select {
+ add { Events.AddHandler (SelectEvent, value); }
+ remove { Events.RemoveHandler (SelectEvent, value); }
+ }
#endregion // Events
#region Public Properties
internal bool MeasureEventDefined {
get {
- if (ownerdraw == true && MeasureItem != null) {
+ if (ownerdraw == true && Events [MeasureItemEvent] != null) {
return true;
} else {
return false;
Text = menuitem.Text;
Visible = menuitem.Visible;
+#if notyet
// Events
Click = menuitem.Click;
DrawItem = menuitem.DrawItem;
MeasureItem = menuitem.MeasureItem;
Popup = menuitem.Popup;
Select = menuitem.Select;
+#endif
}
protected override void Dispose (bool disposing)
protected virtual void OnClick (EventArgs e)
{
- if (Click != null)
- Click (this, e);
+ EventHandler eh = (EventHandler)(Events [ClickEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnDrawItem (DrawItemEventArgs e)
{
if (OwnerDraw) {
- if (DrawItem != null)
- DrawItem (this, e);
+ DrawItemEventHandler eh = (DrawItemEventHandler)(Events [DrawItemEvent]);
+ if (eh != null)
+ eh (this, e);
return;
}
protected virtual void OnMeasureItem (MeasureItemEventArgs e)
{
- if (OwnerDraw && MeasureItem != null)
- MeasureItem (this, e);
+ if (!OwnerDraw)
+ return;
+
+ MeasureItemEventHandler eh = (MeasureItemEventHandler)(Events [MeasureItemEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnPopup (EventArgs e)
{
- if (Popup != null)
- Popup (this, e);
+ EventHandler eh = (EventHandler)(Events [PopupEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnSelect (EventArgs e)
{
- if (Select != null)
- Select (this, e);
+ EventHandler eh = (EventHandler)(Events [SelectEvent]);
+ if (eh != null)
+ eh (this, e);
}
public void PerformClick ()
protected virtual void OnMenuActivate (EventArgs e)
{
- if (MenuActivate != null) MenuActivate (this, e);
+ EventHandler eh = (EventHandler)(Events [MenuActivateEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnMenuDeactivate (EventArgs e)
{
- if (MenuDeactivate != null) MenuDeactivate (this, e);
+ EventHandler eh = (EventHandler)(Events [MenuDeactivateEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override bool ProcessCmdKey (ref Message msg, Keys keyData)
#endregion
#region Public Events
- public event EventHandler MenuActivate;
- public event EventHandler MenuDeactivate;
+ static object MenuActivateEvent = new object ();
+ static object MenuDeactivateEvent = new object ();
+
+ public event EventHandler MenuActivate {
+ add { Events.AddHandler (MenuActivateEvent, value); }
+ remove { Events.RemoveHandler (MenuActivateEvent, value); }
+ }
+
+ public event EventHandler MenuDeactivate {
+ add { Events.AddHandler (MenuDeactivateEvent, value); }
+ remove { Events.RemoveHandler (MenuDeactivateEvent, value); }
+ }
#endregion
#region Internal Methods
[DefaultEvent("MouseDown")]
[Designer ("System.Windows.Forms.Design.NotifyIconDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
[ToolboxItemFilter("System.Windows.Forms", ToolboxItemFilterType.Allow)]
- public sealed class NotifyIcon : System.ComponentModel.Component {
+ public sealed class NotifyIcon : Component {
#region Local Variables
private ContextMenu context_menu;
private Icon icon;
case Msg.WM_USER: {
switch ((Msg)m.LParam.ToInt32()) {
case Msg.WM_LBUTTONDOWN: {
- HandleMouseDown(this, new MouseEventArgs(MouseButtons.Left, 1, Control.MousePosition.X, Control.MousePosition.Y, 0));
+ owner.OnMouseDown (new MouseEventArgs(MouseButtons.Left, 1, Control.MousePosition.X, Control.MousePosition.Y, 0));
return;
}
case Msg.WM_LBUTTONUP: {
- HandleMouseUp(this, new MouseEventArgs(MouseButtons.Left, 1, Control.MousePosition.X, Control.MousePosition.Y, 0));
- HandleClick(this, EventArgs.Empty);
+ owner.OnMouseUp (new MouseEventArgs(MouseButtons.Left, 1, Control.MousePosition.X, Control.MousePosition.Y, 0));
+ owner.OnClick (EventArgs.Empty);
return;
}
case Msg.WM_LBUTTONDBLCLK: {
- HandleDoubleClick(this, EventArgs.Empty);
+ owner.OnDoubleClick (EventArgs.Empty);
return;
}
case Msg.WM_MOUSEMOVE: {
- HandleMouseMove(this, new MouseEventArgs(MouseButtons.None, 1, Control.MousePosition.X, Control.MousePosition.Y, 0));
+ owner.OnMouseMove (new MouseEventArgs(MouseButtons.None, 1, Control.MousePosition.X, Control.MousePosition.Y, 0));
return;
}
case Msg.WM_RBUTTONDOWN: {
- HandleMouseDown(this, new MouseEventArgs(MouseButtons.Right, 1, Control.MousePosition.X, Control.MousePosition.Y, 0));
+ owner.OnMouseDown (new MouseEventArgs(MouseButtons.Right, 1, Control.MousePosition.X, Control.MousePosition.Y, 0));
return;
}
case Msg.WM_RBUTTONUP: {
- HandleMouseUp(this, new MouseEventArgs(MouseButtons.Right, 1, Control.MousePosition.X, Control.MousePosition.Y, 0));
- HandleClick(this, EventArgs.Empty);
+ owner.OnMouseUp (new MouseEventArgs(MouseButtons.Right, 1, Control.MousePosition.X, Control.MousePosition.Y, 0));
+ owner.OnClick (EventArgs.Empty);
return;
}
case Msg.WM_RBUTTONDBLCLK: {
- HandleDoubleClick(this, EventArgs.Empty);
+ owner.OnDoubleClick (EventArgs.Empty);
return;
}
}
owner.Recalculate ();
}
- private void HandleClick(object sender, EventArgs e) {
- if (owner.Click != null) {
- owner.Click(owner, e);
- }
+ private void HandleClick (object sender, EventArgs e)
+ {
+ owner.OnClick (e);
}
- private void HandleDoubleClick(object sender, EventArgs e) {
- if (owner.DoubleClick != null) {
- owner.DoubleClick(owner, e);
- }
+ private void HandleDoubleClick (object sender, EventArgs e)
+ {
+ owner.OnDoubleClick (e);
}
- private void HandleMouseDown(object sender, MouseEventArgs e) {
- if (owner.MouseDown != null) {
- owner.MouseDown(owner, e);
- }
+ private void HandleMouseDown (object sender, MouseEventArgs e)
+ {
+ owner.OnMouseDown (e);
}
- private void HandleMouseUp(object sender, MouseEventArgs e) {
- if ((e.Button & MouseButtons.Right) == MouseButtons.Right && owner.context_menu != null) {
- owner.context_menu.Show(this, new Point(e.X, e.Y));
- }
-
- if (owner.MouseUp != null) {
- owner.MouseUp(owner, e);
- }
+ private void HandleMouseUp (object sender, MouseEventArgs e)
+ {
+ owner.OnMouseUp (e);
}
- private void HandleMouseMove(object sender, MouseEventArgs e) {
- if (owner.MouseMove != null) {
- owner.MouseMove(owner, e);
- }
+ private void HandleMouseMove (object sender, MouseEventArgs e)
+ {
+ owner.OnMouseMove (e);
}
}
#endregion // NotifyIconWindow Class
#endregion // Public Constructors
#region Private Methods
+ private void OnClick (EventArgs e)
+ {
+ EventHandler eh = (EventHandler)(Events [ClickEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ private void OnDoubleClick (EventArgs e)
+ {
+ EventHandler eh = (EventHandler)(Events [DoubleClickEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ private void OnMouseDown (MouseEventArgs e)
+ {
+ MouseEventHandler eh = (MouseEventHandler)(Events [MouseDownEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ private void OnMouseUp (MouseEventArgs e)
+ {
+ if ((e.Button & MouseButtons.Right) == MouseButtons.Right && context_menu != null)
+ context_menu.Show (window, new Point(e.X, e.Y));
+
+ MouseEventHandler eh = (MouseEventHandler)(Events [MouseUpEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ private void OnMouseMove (MouseEventArgs e)
+ {
+ MouseEventHandler eh = (MouseEventHandler)(Events [MouseMoveEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
private void Recalculate ()
{
window.CalculateIconRect ();
#endregion // Protected Instance Methods
#region Events
+ static object ClickEvent = new object ();
+ static object DoubleClickEvent = new object ();
+ static object MouseDownEvent = new object ();
+ static object MouseMoveEvent = new object ();
+ static object MouseUpEvent = new object ();
+
[Category("Action")]
- public event EventHandler Click;
+ public event EventHandler Click {
+ add { Events.AddHandler (ClickEvent, value); }
+ remove { Events.RemoveHandler (ClickEvent, value); }
+ }
[Category("Action")]
- public event EventHandler DoubleClick;
+ public event EventHandler DoubleClick {
+ add { Events.AddHandler (DoubleClickEvent, value); }
+ remove { Events.RemoveHandler (DoubleClickEvent, value); }
+ }
+
+ public event MouseEventHandler MouseDown {
+ add { Events.AddHandler (MouseDownEvent, value); }
+ remove { Events.RemoveHandler (MouseDownEvent, value); }
+ }
+
+ public event MouseEventHandler MouseMove {
+ add { Events.AddHandler (MouseMoveEvent, value); }
+ remove { Events.RemoveHandler (MouseMoveEvent, value); }
+ }
+
+ public event MouseEventHandler MouseUp {
+ add { Events.AddHandler (MouseUpEvent, value); }
+ remove { Events.RemoveHandler (MouseUpEvent, value); }
+ }
- public event MouseEventHandler MouseDown;
- public event MouseEventHandler MouseMove;
- public event MouseEventHandler MouseUp;
#endregion // Events
}
}
protected virtual void OnValueChanged (EventArgs args)
{
- if (ValueChanged != null)
- ValueChanged (this, args);
+ EventHandler eh = (EventHandler)(Events [ValueChangedEvent]);
+ if (eh != null)
+ eh (this, args);
}
- public event EventHandler ValueChanged;
+ static object ValueChangedEvent = new object ();
+ public event EventHandler ValueChanged {
+ add { Events.AddHandler (ValueChangedEvent, value); }
+ remove { Events.RemoveHandler (ValueChangedEvent, value); }
+ }
}
}
}
protected virtual void OnValueChanged(EventArgs e) {
- if (ValueChanged != null) {
- ValueChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [ValueChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected void ParseEditText() {
}
#if NET_2_0
- protected override void OnLostFocus(EventArgs e) {
- base.OnLostFocus(e);
- if (this.UserEdit)
- this.UpdateEditText();
- }
+ protected override void OnLostFocus(EventArgs e) {
+ base.OnLostFocus(e);
+ if (this.UserEdit)
+ this.UpdateEditText();
+ }
#endif
#endregion // Protected Instance Methods
#region Events
- public event EventHandler ValueChanged;
+ static object ValueChangedEvent = new object ();
+ static object TextChangedEvent = new object ();
+
+ public event EventHandler ValueChanged {
+ add { Events.AddHandler (ValueChangedEvent, value); }
+ remove { Events.RemoveHandler (ValueChangedEvent, value); }
+ }
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
- public event EventHandler TextChanged;
+ public event EventHandler TextChanged {
+ add { Events.AddHandler (TextChangedEvent, value); }
+ remove { Events.RemoveHandler (TextChangedEvent, value); }
+ }
#endregion // Events
}
}
#region Events
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
- public event KeyEventHandler KeyDown;
+ public event KeyEventHandler KeyDown;
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
- public event KeyPressEventHandler KeyPress;
+ public event KeyPressEventHandler KeyPress;
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
- public event KeyEventHandler KeyUp;
+ public event KeyEventHandler KeyUp;
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
- public event EventHandler TextChanged;
+ public event EventHandler TextChanged;
#endregion
}
}
protected virtual void OnSizeModeChanged (EventArgs e)
{
- if (SizeModeChanged != null)
- SizeModeChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [SizeModeChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnEnabledChanged (EventArgs e)
remove { base.TextChanged -= value; }
}
- public event EventHandler SizeModeChanged;
+ static object SizeModeChangedEvent = new object ();
+ public event EventHandler SizeModeChanged {
+ add { Events.AddHandler (SizeModeChangedEvent, value); }
+ remove { Events.RemoveHandler (SizeModeChangedEvent, value); }
+ }
+
#endregion // Events
}
}
protected virtual void OnStartPageChanged(EventArgs e)
{
- if (StartPageChanged != null)
- StartPageChanged(this, e);
+ EventHandler eh = (EventHandler)(Events [StartPageChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void WndProc(ref Message m)
#endregion // Protected Instance Methods
- public event EventHandler StartPageChanged;
+ static object StartPageChangedEvent = new object ();
+
+ public event EventHandler StartPageChanged {
+ add { Events.AddHandler (StartPageChangedEvent, value); }
+ remove { Events.RemoveHandler (StartPageChangedEvent, value); }
+ }
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler BackColorChanged {
- add {
- base.BackColorChanged += value;
- }
-
- remove {
- base.BackColorChanged -= value;
- }
+ add { base.BackColorChanged += value; }
+ remove { base.BackColorChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler BackgroundImageChanged {
- add {
- base.BackgroundImageChanged += value;
- }
-
- remove {
- base.BackgroundImageChanged -= value;
- }
+ add { base.BackgroundImageChanged += value; }
+ remove { base.BackgroundImageChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler CausesValidationChanged {
- add {
- base.CausesValidationChanged += value;
- }
-
- remove {
- base.CausesValidationChanged -= value;
- }
+ add { base.CausesValidationChanged += value; }
+ remove { base.CausesValidationChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler ContextMenuChanged {
- add {
- base.ContextMenuChanged += value;
- }
-
- remove {
- base.ContextMenuChanged -= value;
- }
+ add { base.ContextMenuChanged += value; }
+ remove { base.ContextMenuChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler CursorChanged {
- add {
- base.CursorChanged += value;
- }
-
- remove {
- base.CursorChanged -= value;
- }
+ add { base.CursorChanged += value; }
+ remove { base.CursorChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler DockChanged {
- add {
- base.DockChanged += value;
- }
-
- remove {
- base.DockChanged -= value;
- }
+ add { base.DockChanged += value; }
+ remove { base.DockChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler EnabledChanged {
- add {
- base.EnabledChanged += value;
- }
-
- remove {
- base.EnabledChanged -= value;
- }
+ add { base.EnabledChanged += value; }
+ remove { base.EnabledChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler FontChanged {
- add {
- base.FontChanged += value;
- }
-
- remove {
- base.FontChanged -= value;
- }
+ add { base.FontChanged += value; }
+ remove { base.FontChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler ForeColorChanged {
- add {
- base.ForeColorChanged += value;
- }
-
- remove {
- base.ForeColorChanged -= value;
- }
+ add { base.ForeColorChanged += value; }
+ remove { base.ForeColorChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler ImeModeChanged {
- add {
- base.ImeModeChanged += value;
- }
-
- remove {
- base.ImeModeChanged -= value;
- }
+ add { base.ImeModeChanged += value; }
+ remove { base.ImeModeChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler LocationChanged {
- add {
- base.LocationChanged += value;
- }
-
- remove {
- base.LocationChanged -= value;
- }
+ add { base.LocationChanged += value; }
+ remove { base.LocationChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler MaximumSizeChanged {
- add {
- base.MaximumSizeChanged += value;
- }
-
- remove {
- base.MaximumSizeChanged -= value;
- }
+ add { base.MaximumSizeChanged += value; }
+ remove { base.MaximumSizeChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler MinimumSizeChanged {
- add {
- base.MinimumSizeChanged += value;
- }
-
- remove {
- base.MinimumSizeChanged -= value;
- }
+ add { base.MinimumSizeChanged += value; }
+ remove { base.MinimumSizeChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler RightToLeftChanged {
- add {
- base.RightToLeftChanged += value;
- }
-
- remove {
- base.RightToLeftChanged -= value;
- }
+ add { base.RightToLeftChanged += value; }
+ remove { base.RightToLeftChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler SizeChanged {
- add {
- base.SizeChanged += value;
- }
-
- remove {
- base.SizeChanged -= value;
- }
+ add { base.SizeChanged += value; }
+ remove { base.SizeChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler TabStopChanged {
- add {
- base.TabStopChanged += value;
- }
-
- remove {
- base.TabStopChanged -= value;
- }
+ add { base.TabStopChanged += value; }
+ remove { base.TabStopChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler TextChanged {
- add {
- base.TextChanged += value;
- }
-
- remove {
- base.TextChanged -= value;
- }
+ add { base.TextChanged += value; }
+ remove { base.TextChanged -= value; }
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler VisibleChanged {
- add {
- base.VisibleChanged += value;
- }
-
- remove {
- base.VisibleChanged -= value;
- }
+ add { base.VisibleChanged += value; }
+ remove { base.VisibleChanged -= value; }
}
}
}
UpdateToolBarButtons();
ReflectObjects();
property_grid_view.Refresh();
-
- if (PropertySortChanged != null) {
- PropertySortChanged(this, EventArgs.Empty);
- }
+
+ EventHandler eh = (EventHandler)(Events [PropertySortChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
}
}
protected virtual void OnPropertyValueChanged (PropertyValueChangedEventArgs e) {
- if (PropertyValueChanged != null) {
- PropertyValueChanged(this, e);
+ PropertyValueChangedEventHandler eh = (PropertyValueChangedEventHandler)(Events [PropertyValueChangedEvent]);
+ if (eh != null) {
+ eh (this, e);
current_property_value = selected_grid_item.Value;
}
}
}
protected virtual void OnSelectedGridItemChanged (SelectedGridItemChangedEventArgs e) {
- if (SelectedGridItemChanged != null) {
- SelectedGridItemChanged(this, e);
- }
+ SelectedGridItemChangedEventHandler eh = (SelectedGridItemChangedEventHandler)(Events [SelectedGridItemChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnSelectedObjectsChanged (EventArgs e) {
- if (SelectedObjectsChanged != null) {
- SelectedObjectsChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [SelectedObjectsChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnSystemColorsChanged (EventArgs e) {
#endregion
#region Events
- public event EventHandler PropertySortChanged;
- public event PropertyTabChangedEventHandler PropertyTabChanged;
- public event PropertyValueChangedEventHandler PropertyValueChanged;
- public event SelectedGridItemChangedEventHandler SelectedGridItemChanged;
- public event EventHandler SelectedObjectsChanged;
+ static object PropertySortChangedEvent = new object ();
+ static object PropertyTabChangedEvent = new object ();
+ static object PropertyValueChangedEvent = new object ();
+ static object SelectedGridItemChangedEvent = new object ();
+ static object SelectedObjectsChangedEvent = new object ();
+
+ public event EventHandler PropertySortChanged {
+ add { Events.AddHandler (PropertySortChangedEvent, value); }
+ remove { Events.RemoveHandler (PropertySortChangedEvent, value); }
+ }
+
+ public event PropertyTabChangedEventHandler PropertyTabChanged {
+ add { Events.AddHandler (PropertyTabChangedEvent, value); }
+ remove { Events.RemoveHandler (PropertyTabChangedEvent, value); }
+ }
+
+ public event PropertyValueChangedEventHandler PropertyValueChanged {
+ add { Events.AddHandler (PropertyValueChangedEvent, value); }
+ remove { Events.RemoveHandler (PropertyValueChangedEvent, value); }
+ }
+
+ public event SelectedGridItemChangedEventHandler SelectedGridItemChanged {
+ add { Events.AddHandler (SelectedGridItemChangedEvent, value); }
+ remove { Events.RemoveHandler (SelectedGridItemChangedEvent, value); }
+ }
+
+ public event EventHandler SelectedObjectsChanged {
+ add { Events.AddHandler (SelectedObjectsChangedEvent, value); }
+ remove { Events.RemoveHandler (SelectedObjectsChangedEvent, value); }
+ }
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
#endregion Public Instance Properties
#region Events
+ static object DropDownButtonClickedEvent = new object ();
+ static object DialogButtonClickedEvent = new object ();
+ static object ToggleValueEvent = new object ();
- public event EventHandler DropDownButtonClicked;
- public event EventHandler DialogButtonClicked;
- public event EventHandler ToggleValue;
+ public event EventHandler DropDownButtonClicked {
+ add { Events.AddHandler (DropDownButtonClickedEvent, value); }
+ remove { Events.RemoveHandler (DropDownButtonClickedEvent, value); }
+ }
+
+ public event EventHandler DialogButtonClicked {
+ add { Events.AddHandler (DialogButtonClickedEvent, value); }
+ remove { Events.RemoveHandler (DialogButtonClickedEvent, value); }
+ }
+
+ public event EventHandler ToggleValue {
+ add { Events.AddHandler (ToggleValueEvent, value); }
+ remove { Events.RemoveHandler (ToggleValueEvent, value); }
+ }
#endregion Events
e.Graphics.DrawString("...", new Font(Font,FontStyle.Bold), Brushes.Black, 0,0);
}
- private void dropdown_button_Click(object sender, System.EventArgs e) {
- if (DropDownButtonClicked != null)
- DropDownButtonClicked(this, EventArgs.Empty);
+ private void dropdown_button_Click(object sender, EventArgs e) {
+ EventHandler eh = (EventHandler)(Events [DropDownButtonClickedEvent]);
+ if (eh != null)
+ eh (this, e);
}
- private void dialog_button_Click(object sender, System.EventArgs e) {
- if (DialogButtonClicked != null)
- DialogButtonClicked(this, EventArgs.Empty);
+ private void dialog_button_Click(object sender, EventArgs e) {
+ EventHandler eh = (EventHandler)(Events [DialogButtonClickedEvent]);
+ if (eh != null)
+ eh (this, e);
}
#endregion Private Helper Methods
private void textbox_DoubleClick(object sender, EventArgs e) {
- if (ToggleValue != null)
- ToggleValue(this, EventArgs.Empty);
+ EventHandler eh = (EventHandler)(Events [ToggleValueEvent]);
+ if (eh != null)
+ eh (this, e);
}
}
}
set {
if (value != appearance) {
appearance = value;
- if (AppearanceChanged != null) {
- AppearanceChanged(this, EventArgs.Empty);
- }
+ EventHandler eh = (EventHandler)(Events [AppearanceChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
Redraw();
}
}
}
protected virtual void OnCheckedChanged(EventArgs e) {
- if (CheckedChanged != null) {
- CheckedChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [CheckedChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnClick(EventArgs e) {
#endregion // Protected Instance Methods
#region Events
- public event EventHandler AppearanceChanged;
- public event EventHandler CheckedChanged;
+ static object AppearanceChangedEvent = new object ();
+ static object CheckedChangedEvent = new object ();
+
+ public event EventHandler AppearanceChanged {
+ add { Events.AddHandler (AppearanceChangedEvent, value); }
+ remove { Events.RemoveHandler (AppearanceChangedEvent, value); }
+ }
+
+ public event EventHandler CheckedChanged {
+ add { Events.AddHandler (CheckedChangedEvent, value); }
+ remove { Events.RemoveHandler (CheckedChangedEvent, value); }
+ }
[Browsable(false)]
[EditorBrowsable (EditorBrowsableState.Never)]
}
protected virtual void OnContentsResized(ContentsResizedEventArgs e) {
- if (ContentsResized != null) {
- ContentsResized(this, e);
- }
+ ContentsResizedEventHandler eh = (ContentsResizedEventHandler)(Events [ContentsResizedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnContextMenuChanged(EventArgs e) {
}
protected virtual void OnHScroll(EventArgs e) {
- if (HScroll != null) {
- HScroll(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [HScrollEvent]);
+ if (eh != null)
+ eh (this, e);
}
[MonoTODO("Determine when to call this")]
protected virtual void OnImeChange(EventArgs e) {
- if (ImeChange != null) {
- ImeChange(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [ImeChangeEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnLinkClicked(LinkClickedEventArgs e) {
- if (LinkClicked != null) {
- LinkClicked(this, e);
- }
+ LinkClickedEventHandler eh = (LinkClickedEventHandler)(Events [LinkClickedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnProtected(EventArgs e) {
- if (Protected != null) {
- Protected(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [ProtectedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnRightToLeftChanged(EventArgs e) {
}
protected virtual void OnSelectionChanged(EventArgs e) {
- if (SelectionChanged != null) {
- SelectionChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [SelectionChanged]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnSystemColorsChanged(EventArgs e) {
#endregion // Protected Instance Methods
#region Events
+ static object ContentsResizedEvent = new object ();
+ static object HScrollEvent = new object ();
+ static object ImeChangeEvent = new object ();
+ static object LinkClickedEvent = new object ();
+ static object ProtectedEvent = new object ();
+ static object SelectionChangedEvent = new object ();
+ static object VScrollEvent = new object ();
+
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event EventHandler BackgroundImageChanged;
- public event ContentsResizedEventHandler ContentsResized;
+ public event ContentsResizedEventHandler ContentsResized {
+ add { Events.AddHandler (ContentsResizedEvent, value); }
+ remove { Events.RemoveHandler (ContentsResizedEvent, value); }
+ }
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event GiveFeedbackEventHandler GiveFeedback;
- public event EventHandler HScroll;
- public event EventHandler ImeChange;
- public event LinkClickedEventHandler LinkClicked;
- public event EventHandler Protected;
+ public event EventHandler HScroll {
+ add { Events.AddHandler (HScrollEvent, value); }
+ remove { Events.RemoveHandler (HScrollEvent, value); }
+ }
+
+ public event EventHandler ImeChange {
+ add { Events.AddHandler (ImeChangeEvent, value); }
+ remove { Events.RemoveHandler (ImeChangeEvent, value); }
+ }
+
+ public event LinkClickedEventHandler LinkClicked {
+ add { Events.AddHandler (LinkClickedEvent, value); }
+ remove { Events.RemoveHandler (LinkClickedEvent, value); }
+ }
+
+ public event EventHandler Protected {
+ add { Events.AddHandler (ProtectedEvent, value); }
+ remove { Events.RemoveHandler (ProtectedEvent, value); }
+ }
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
remove { base.Paint -= value; }
}
- public event ScrollEventHandler Scroll;
+ static object ScrollEvent = new object ();
+ static object ValueChangedEvent = new object ();
+
+ public event ScrollEventHandler Scroll {
+ add { Events.AddHandler (ScrollEvent, value); }
+ remove { Events.RemoveHandler (ScrollEvent, value); }
+ }
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
remove { base.TextChanged -= value; }
}
- public event EventHandler ValueChanged;
+ public event EventHandler ValueChanged {
+ add { Events.AddHandler (ValueChangedEvent, value); }
+ remove { Events.RemoveHandler (ValueChangedEvent, value); }
+ }
#endregion Events
public ScrollBar ()
protected virtual void OnScroll (ScrollEventArgs event_args)
{
- if (Scroll == null)
+ ScrollEventHandler eh = (ScrollEventHandler)(Events [ScrollEvent]);
+ if (eh == null)
return;
if (event_args.NewValue < Minimum) {
event_args.NewValue = Maximum;
}
- Scroll (this, event_args);
+ eh (this, event_args);
}
private void SendWMScroll(ScrollBarCommands cmd) {
protected virtual void OnValueChanged (EventArgs e)
{
- if (ValueChanged != null) {
- ValueChanged (this, e);
- }
+ EventHandler eh = (EventHandler)(Events [ValueChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
public override string ToString()
else {
position = pos; // Updates directly the value to avoid thumb pos update
- if (ValueChanged != null)
- ValueChanged (this, EventArgs.Empty);
+
+ // XXX some reason we don't call OnValueChanged?
+ EventHandler eh = (EventHandler)(Events [ValueChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
}
[Browsable (false)]
[EditorBrowsable (EditorBrowsableState.Never)]
new public event EventHandler AutoSizeChanged;
- public event SplitterEventHandler SplitterMoved;
- public event SplitterCancelEventHandler SplitterMoving;
+
+ static object SplitterMovedEvent = new object ();
+ static object SplitterMovingEvent = new object ();
+
+ public event SplitterEventHandler SplitterMoved {
+ add { Events.AddHandler (SplitterMovedEvent, value); }
+ remove { Events.RemoveHandler (SplitterMovedEvent, value); }
+ }
+
+ public event SplitterCancelEventHandler SplitterMoving {
+ add { Events.AddHandler (SplitterMovingEvent, value); }
+ remove { Events.RemoveHandler (SplitterMovingEvent, value); }
+ }
#endregion
#region Public Constructors
#region Public Methods
public void OnSplitterMoved (SplitterEventArgs e)
{
- if (SplitterMoved != null) SplitterMoved (this, e);
+ SplitterEventHandler eh = (SplitterEventHandler)(Events [SplitterMovedEvent]);
+ if (eh != null)
+ eh (this, e);
}
public void OnSplitterMoving (SplitterCancelEventArgs e)
{
- if (SplitterMoving != null) SplitterMoving (this, e);
+ SplitterCancelEventHandler eh = (SplitterCancelEventHandler)(Events [SplitterMovingEvent]);
+ if (eh != null)
+ eh (this, e);
if (e.Cancel == true) {
e.SplitX = splitter.Location.X;
#endregion
}
}
-#endif
\ No newline at end of file
+#endif
}
protected virtual void OnSplitterMoved(SplitterEventArgs sevent) {
- if (SplitterMoved != null) {
- SplitterMoved(this, sevent);
- }
+ SplitterEventHandler eh = (SplitterEventHandler)(Events [SplitterMovedEvent]);
+ if (eh != null)
+ eh (this, sevent);
}
protected virtual void OnSplitterMoving(SplitterEventArgs sevent) {
- if (SplitterMoving != null) {
- SplitterMoving(this, sevent);
- }
+ SplitterEventHandler eh = (SplitterEventHandler)(Events [SplitterMovingEvent]);
+ if (eh != null)
+ eh (this, sevent);
}
protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) {
remove { base.TextChanged -= value; }
}
- public event SplitterEventHandler SplitterMoved;
- public event SplitterEventHandler SplitterMoving;
+ static object SplitterMovedEvent = new object ();
+ static object SplitterMovingEvent = new object ();
+
+ public event SplitterEventHandler SplitterMoved {
+ add { Events.AddHandler (SplitterMovedEvent, value); }
+ remove { Events.RemoveHandler (SplitterMovedEvent, value); }
+ }
+
+ public event SplitterEventHandler SplitterMoving {
+ add { Events.AddHandler (SplitterMovingEvent, value); }
+ remove { Events.RemoveHandler (SplitterMovingEvent, value); }
+ }
#endregion // Events
}
}
}
protected virtual void OnDrawItem (StatusBarDrawItemEventArgs e) {
- if (DrawItem != null)
- DrawItem (this, e);
+ StatusBarDrawItemEventHandler eh = (StatusBarDrawItemEventHandler)(Events [DrawItemEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnHandleCreated (EventArgs e) {
}
protected virtual void OnPanelClick (StatusBarPanelClickEventArgs e) {
- if (PanelClick != null)
- PanelClick (this, e);
+ StatusBarPanelClickEventHandler eh = (StatusBarPanelClickEventHandler)(Events [PanelClickEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnResize (EventArgs e)
remove { base.Paint -= value; }
}
- public event StatusBarDrawItemEventHandler DrawItem;
- public event StatusBarPanelClickEventHandler PanelClick;
+ static object DrawItemEvent = new object ();
+ static object PanelClickEvent = new object ();
+
+ public event StatusBarDrawItemEventHandler DrawItem {
+ add { Events.AddHandler (DrawItemEvent, value); }
+ remove { Events.RemoveHandler (DrawItemEvent, value); }
+ }
+
+ public event StatusBarPanelClickEventHandler PanelClick {
+ add { Events.AddHandler (PanelClickEvent, value); }
+ remove { Events.RemoveHandler (PanelClickEvent, value); }
+ }
#endregion // Events
#endregion
#region Public Events
- public event EventHandler PaddingChanged;
+ static object PaddingChangedEvent = new object ();
+
+ public event EventHandler PaddingChanged {
+ add { Events.AddHandler (PaddingChangedEvent, value); }
+ remove { Events.RemoveHandler (PaddingChangedEvent, value); }
+ }
#endregion
}
}
-#endif
\ No newline at end of file
+#endif
protected virtual void OnDrawItem (DrawItemEventArgs e)
{
- if (DrawItem != null && DrawMode == TabDrawMode.OwnerDrawFixed)
- DrawItem (this, e);
+ if (DrawMode != TabDrawMode.OwnerDrawFixed)
+ return;
+
+ DrawItemEventHandler eh = (DrawItemEventHandler)(Events [DrawItemEvent]);
+ if (eh != null)
+ eh (this, e);
}
internal void OnDrawItemInternal (DrawItemEventArgs e)
protected virtual void OnSelectedIndexChanged (EventArgs e)
{
- if (SelectedIndexChanged != null)
- SelectedIndexChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [SelectedIndexChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
internal override void OnPaintInternal (PaintEventArgs pe)
remove { base.TextChanged -= value; }
}
- public event DrawItemEventHandler DrawItem;
- public event EventHandler SelectedIndexChanged;
+ static object DrawItemEvent = new object ();
+ static object SelectedIndexChangedEvent = new object ();
+
+ public event DrawItemEventHandler DrawItem {
+ add { Events.AddHandler (DrawItemEvent, value); }
+ remove { Events.RemoveHandler (DrawItemEvent, value); }
+ }
+
+ public event EventHandler SelectedIndexChanged {
+ add { Events.AddHandler (SelectedIndexChangedEvent, value); }
+ remove { Events.RemoveHandler (SelectedIndexChangedEvent, value); }
+ }
#endregion // Events
protected virtual void OnAcceptsTabChanged(EventArgs e) {
- if (AcceptsTabChanged != null) {
- AcceptsTabChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [AcceptsTabChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnAutoSizeChanged(EventArgs e) {
- if (AutoSizeChanged != null) {
- AutoSizeChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [AutoSizeChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnBorderStyleChanged(EventArgs e) {
- if (BorderStyleChanged != null) {
- BorderStyleChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [BorderStyleChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnFontChanged(EventArgs e) {
}
protected virtual void OnHideSelectionChanged(EventArgs e) {
- if (HideSelectionChanged != null) {
- HideSelectionChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [HideSelectionChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnModifiedChanged(EventArgs e) {
- if (ModifiedChanged != null) {
- ModifiedChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [ModifiedChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnMultilineChanged(EventArgs e) {
- if (MultilineChanged != null) {
- MultilineChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [MultilineChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnReadOnlyChanged(EventArgs e) {
- if (ReadOnlyChanged != null) {
- ReadOnlyChanged(this, e);
- }
+ EventHandler eh = (EventHandler)(Events [ReadOnlyChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override bool ProcessDialogKey(Keys keyData) {
#endregion // Protected Instance Methods
#region Events
- public event EventHandler AcceptsTabChanged;
- public event EventHandler AutoSizeChanged;
+ static object AcceptsTabChangedEvent = new object ();
+ static object AutoSizeChangedEvent = new object ();
+ static object BorderStyleChangedEvent = new object ();
+ static object HideSelectionChangedEvent = new object ();
+ static object ModifiedChangedEvent = new object ();
+ static object MultilineChangedEvent = new object ();
+ static object ReadOnlyChangedEvent = new object ();
+ static object HScrolledEvent = new object ();
+ static object VScrolledEvent = new object ();
+
+ public event EventHandler AcceptsTabChanged {
+ add { Events.AddHandler (AcceptsTabChangedEvent, value); }
+ remove { Events.RemoveHandler (AcceptsTabChangedEvent, value); }
+ }
+
+ public event EventHandler AutoSizeChanged {
+ add { Events.AddHandler (AutoSizeChangedEvent, value); }
+ remove { Events.RemoveHandler (AutoSizeChangedEvent, value); }
+ }
+
+ public event EventHandler BorderStyleChanged {
+ add { Events.AddHandler (BorderStyleChangedEvent, value); }
+ remove { Events.RemoveHandler (BorderStyleChangedEvent, value); }
+ }
+
+ public event EventHandler HideSelectionChanged {
+ add { Events.AddHandler (HideSelectionChangedEvent, value); }
+ remove { Events.RemoveHandler (HideSelectionChangedEvent, value); }
+ }
+
+ public event EventHandler ModifiedChanged {
+ add { Events.AddHandler (ModifiedChangedEvent, value); }
+ remove { Events.RemoveHandler (ModifiedChangedEvent, value); }
+ }
+
+ public event EventHandler MultilineChanged {
+ add { Events.AddHandler (MultilineChangedEvent, value); }
+ remove { Events.RemoveHandler (MultilineChangedEvent, value); }
+ }
+
+ public event EventHandler ReadOnlyChanged {
+ add { Events.AddHandler (ReadOnlyChangedEvent, value); }
+ remove { Events.RemoveHandler (ReadOnlyChangedEvent, value); }
+ }
+
+ internal event EventHandler HScrolled {
+ add { Events.AddHandler (HScrolledEvent, value); }
+ remove { Events.RemoveHandler (HScrolledEvent, value); }
+ }
+
+ internal event EventHandler VScrolled {
+ add { Events.AddHandler (VScrolledEvent, value); }
+ remove { Events.RemoveHandler (VScrolledEvent, value); }
+ }
+
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public new event EventHandler BackgroundImageChanged {
add { base.BackgroundImageChanged += value; }
remove { base.BackgroundImageChanged -= value; }
}
- public event EventHandler BorderStyleChanged;
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
public event EventHandler Click {
remove { base.Click -= value; }
}
- public event EventHandler HideSelectionChanged;
- public event EventHandler ModifiedChanged;
- public event EventHandler MultilineChanged;
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public event PaintEventHandler Paint;
- public event EventHandler ReadOnlyChanged;
-
- internal event EventHandler HScrolled;
- internal event EventHandler VScrolled;
#endregion // Events
#region Private Methods
}
document.UpdateCaret();
- if (HScrolled != null) {
- HScrolled(this, EventArgs.Empty);
- }
+ EventHandler eh = (EventHandler)(Events [HScrolledEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
private void vscroll_ValueChanged(object sender, EventArgs e) {
}
document.UpdateCaret();
- if (VScrolled != null) {
- VScrolled(this, EventArgs.Empty);
- }
+ EventHandler eh = (EventHandler)(Events [VScrolledEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
}
private void TextBoxBase_MouseMove(object sender, MouseEventArgs e) {
remove { base.TextChanged -= value; }
}
- public event EventHandler Scroll;
- public event EventHandler ValueChanged;
+ static object ScrollEvent = new object ();
+ static object ValueChangedEvent = new object ();
+
+ public event EventHandler Scroll {
+ add { Events.AddHandler (ScrollEvent, value); }
+ remove { Events.RemoveHandler (ScrollEvent, value); }
+ }
+
+ public event EventHandler ValueChanged {
+ add { Events.AddHandler (ValueChangedEvent, value); }
+ remove { Events.RemoveHandler (ValueChangedEvent, value); }
+ }
#endregion // Events
if (position != value) {
position = value;
-
- if (ValueChanged != null)
- ValueChanged (this, new EventArgs ());
-
+
+ // XXX any reason we don't call OnValueChanged here?
+ EventHandler eh = (EventHandler)(Events [ValueChangedEvent]);
+ if (eh != null)
+ eh (this, EventArgs.Empty);
+
Invalidate (thumb_area);
}
}
protected virtual void OnScroll (EventArgs e)
{
- if (Scroll != null)
- Scroll (this, e);
+ EventHandler eh = (EventHandler)(Events [ScrollEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnValueChanged (EventArgs e)
{
- if (ValueChanged != null)
- ValueChanged (this, e);
+ EventHandler eh = (EventHandler)(Events [ValueChangedEvent]);
+ if (eh != null)
+ eh (this, e);
}
public void SetRange (int minValue, int maxValue)
private int update_stack;
private bool update_needed;
- private TreeViewEventHandler on_after_check;
- private TreeViewEventHandler on_after_collapse;
- private TreeViewEventHandler on_after_expand;
- private NodeLabelEditEventHandler on_after_label_edit;
- private TreeViewEventHandler on_after_select;
- private TreeViewCancelEventHandler on_before_check;
- private TreeViewCancelEventHandler on_before_collapse;
- private TreeViewCancelEventHandler on_before_expand;
- private NodeLabelEditEventHandler on_before_label_edit;
- private TreeViewCancelEventHandler on_before_select;
-
private Pen dash;
private StringFormat string_format;
protected virtual void OnItemDrag (ItemDragEventArgs e)
{
- if (ItemDrag != null)
- ItemDrag (this, e);
+ ItemDragEventHandler eh = (ItemDragEventHandler)(Events [ItemDragEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected internal virtual void OnAfterCheck (TreeViewEventArgs e) {
- if (on_after_check != null)
- on_after_check (this, e);
+ TreeViewEventHandler eh = (TreeViewEventHandler)(Events [AfterCheckEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected internal virtual void OnAfterCollapse (TreeViewEventArgs e) {
- if (on_after_collapse != null)
- on_after_collapse (this, e);
+ TreeViewEventHandler eh = (TreeViewEventHandler)(Events [AfterCollapseEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected internal virtual void OnAfterExpand (TreeViewEventArgs e) {
- if (on_after_expand != null)
- on_after_expand (this, e);
+ TreeViewEventHandler eh = (TreeViewEventHandler)(Events [AfterExpandEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnAfterLabelEdit (NodeLabelEditEventArgs e) {
- if (on_after_label_edit != null)
- on_after_label_edit (this, e);
+ NodeLabelEditEventHandler eh = (NodeLabelEditEventHandler)(Events [AfterLabelEditEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnAfterSelect (TreeViewEventArgs e) {
- if (on_after_select != null)
- on_after_select (this, e);
+ TreeViewEventHandler eh = (TreeViewEventHandler)(Events [AfterSelectEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected internal virtual void OnBeforeCheck (TreeViewCancelEventArgs e) {
- if (on_before_check != null)
- on_before_check (this, e);
+ TreeViewCancelEventHandler eh = (TreeViewCancelEventHandler)(Events [BeforeCheckEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected internal virtual void OnBeforeCollapse (TreeViewCancelEventArgs e) {
- if (on_before_collapse != null)
- on_before_collapse (this, e);
+ TreeViewCancelEventHandler eh = (TreeViewCancelEventHandler)(Events [BeforeCollapseEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected internal virtual void OnBeforeExpand (TreeViewCancelEventArgs e) {
- if (on_before_expand != null)
- on_before_expand (this, e);
+ TreeViewCancelEventHandler eh = (TreeViewCancelEventHandler)(Events [BeforeExpandEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnBeforeLabelEdit (NodeLabelEditEventArgs e) {
- if (on_before_label_edit != null)
- on_before_label_edit (this, e);
+ NodeLabelEditEventHandler eh = (NodeLabelEditEventHandler)(Events [BeforeLabelEditEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected virtual void OnBeforeSelect (TreeViewCancelEventArgs e) {
- if (on_before_select != null)
- on_before_select (this, e);
+ TreeViewCancelEventHandler eh = (TreeViewCancelEventHandler)(Events [BeforeSelectEvent]);
+ if (eh != null)
+ eh (this, e);
}
protected override void OnHandleCreated (EventArgs e) {
#endregion // Internal & Private Methods and Properties
#region Events
- public event ItemDragEventHandler ItemDrag;
+ static object ItemDragEvent = new object ();
+ static object AfterCheckEvent = new object ();
+ static object AfterCollapseEvent = new object ();
+ static object AfterExpandEvent = new object ();
+ static object AfterLabelEditEvent = new object ();
+ static object AfterSelectEvent = new object ();
+ static object BeforeCheckEvent = new object ();
+ static object BeforeCollapseEvent = new object ();
+ static object BeforeExpandEvent = new object ();
+ static object BeforeLabelEditEvent = new object ();
+ static object BeforeSelectEvent = new object ();
+
+ public event ItemDragEventHandler ItemDrag {
+ add { Events.AddHandler (ItemDragEvent, value); }
+ remove { Events.RemoveHandler (ItemDragEvent, value); }
+ }
public event TreeViewEventHandler AfterCheck {
- add { on_after_check += value; }
- remove { on_after_check -= value; }
+ add { Events.AddHandler (AfterCheckEvent, value); }
+ remove { Events.RemoveHandler (AfterCheckEvent, value); }
}
public event TreeViewEventHandler AfterCollapse {
- add { on_after_collapse += value; }
- remove { on_after_collapse -= value; }
+ add { Events.AddHandler (AfterCollapseEvent, value); }
+ remove { Events.RemoveHandler (AfterCollapseEvent, value); }
}
public event TreeViewEventHandler AfterExpand {
- add { on_after_expand += value; }
- remove { on_after_expand -= value; }
+ add { Events.AddHandler (AfterExpandEvent, value); }
+ remove { Events.RemoveHandler (AfterExpandEvent, value); }
}
public event NodeLabelEditEventHandler AfterLabelEdit {
- add { on_after_label_edit += value; }
- remove { on_after_label_edit -= value; }
+ add { Events.AddHandler (AfterLabelEditEvent, value); }
+ remove { Events.RemoveHandler (AfterLabelEditEvent, value); }
}
public event TreeViewEventHandler AfterSelect {
- add { on_after_select += value; }
- remove { on_after_select -= value; }
+ add { Events.AddHandler (AfterSelectEvent, value); }
+ remove { Events.RemoveHandler (AfterSelectEvent, value); }
}
- [Browsable (false)]
- [EditorBrowsable (EditorBrowsableState.Never)]
- public event EventHandler BackgroundImageChanged {
- add { base.BackgroundImageChanged += value; }
- remove { base.BackgroundImageChanged -= value; }
+ public event TreeViewEventHandler BeforeCheck {
+ add { Events.AddHandler (BeforeCheckEvent, value); }
+ remove { Events.RemoveHandler (BeforeCheckEvent, value); }
}
- public event TreeViewCancelEventHandler BeforeCheck {
- add { on_before_check += value; }
- remove { on_before_check -= value; }
+ public event TreeViewEventHandler BeforeCollapse {
+ add { Events.AddHandler (BeforeCollapseEvent, value); }
+ remove { Events.RemoveHandler (BeforeCollapseEvent, value); }
}
- public event TreeViewCancelEventHandler BeforeCollapse {
- add { on_before_collapse += value; }
- remove { on_before_collapse -= value; }
+ public event TreeViewEventHandler BeforeExpand {
+ add { Events.AddHandler (BeforeExpandEvent, value); }
+ remove { Events.RemoveHandler (BeforeExpandEvent, value); }
}
- public event TreeViewCancelEventHandler BeforeExpand {
- add { on_before_expand += value; }
- remove { on_before_expand -= value; }
+ public event NodeLabelEditEventHandler BeforeLabelEdit {
+ add { Events.AddHandler (BeforeLabelEditEvent, value); }
+ remove { Events.RemoveHandler (BeforeLabelEditEvent, value); }
}
- public event NodeLabelEditEventHandler BeforeLabelEdit {
- add { on_before_label_edit += value; }
- remove { on_before_label_edit -= value; }
+ public event TreeViewEventHandler BeforeSelect {
+ add { Events.AddHandler (BeforeSelectEvent, value); }
+ remove { Events.RemoveHandler (BeforeSelectEvent, value); }
}
- public event TreeViewCancelEventHandler BeforeSelect {
- add { on_before_select += value; }
- remove { on_before_select -= value; }
+ [Browsable (false)]
+ [EditorBrowsable (EditorBrowsableState.Never)]
+ public event EventHandler BackgroundImageChanged {
+ add { base.BackgroundImageChanged += value; }
+ remove { base.BackgroundImageChanged -= value; }
}
[EditorBrowsable (EditorBrowsableState.Never)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnLoad(EventArgs e) {
- if (Load != null) Load(this, e);
+ EventHandler eh = (EventHandler)(Events [LoadEvent]);
+ if (eh != null)
+ eh (this, e);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
#endregion // Protected Instance Methods
#region Events
- public event EventHandler Load;
+ static object LoadEvent = new object ();
+ static object TextChangedEvent = new object ();
+
+ public event EventHandler Load {
+ add { Events.AddHandler (LoadEvent, value); }
+ remove { Events.RemoveHandler (LoadEvent, value); }
+ }
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
- public event EventHandler TextChanged;
+ public event EventHandler TextChanged {
+ add { Events.AddHandler (TextChangedEvent, value); }
+ remove { Events.RemoveHandler (TextChangedEvent, value); }
+ }
+
#endregion // Events
}
}
projects / mono.git / commitdiff