/// <summary>
/// Displays a list of available values for the specified component than sets the value.
/// </summary>
/// <param name="context">An ITypeDescriptorContext that can be used to gain additional context information.</param>
/// <param name="provider">A service provider object through which editing services may be obtained.</param>
/// <param name="value">An instance of the value being edited.</param>
/// <returns>The new value of the object. If the value of the object hasn't changed, this method should return the same object it was passed.</returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (provider != null)
{
// This service is in charge of popping our ListBox.
_service = ((IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService)));
if (_service != null && value is DropDownListProperty)
{
var property = (DropDownListProperty) value;
var list = new ListBox();
list.Click += ListBox_Click;
foreach (string item in property.Values)
{
list.Items.Add(item);
}
// Drop the list control.
_service.DropDownControl(list);
if (list.SelectedItem != null && list.SelectedIndices.Count == 1)
{
property.SelectedItem = list.SelectedItem.ToString();
value = property;
}
}
}
return value;
}
public override object EditValue( ITypeDescriptorContext context, IServiceProvider provider, object value )
{
if( context != null && provider != null )
{
editorService = (IWindowsFormsEditorService)provider.GetService( typeof( IWindowsFormsEditorService ) );
if( editorService != null )
{
// Create a new trackbar and set it up.
TrackBar trackBar = new TrackBar();
trackBar.ValueChanged += new EventHandler( this.ValueChanged );
trackBar.MouseLeave += new EventHandler( this.MouseLeave );
trackBar.Minimum = 0;
trackBar.Maximum = 100;
trackBar.TickStyle = TickStyle.None;
// Get the low/high values.
PropertyDescriptor prop = context.PropertyDescriptor;
RangeAttribute ra = prop.Attributes[typeof( RangeAttribute )] as RangeAttribute;
valueLow = ra.Low;
valueHigh = ra.High;
// Set the corresponding trackbar value.
double percent = ( System.Convert.ToDouble( value ) - valueLow ) / ( valueHigh - valueLow );
trackBar.Value = (int)( 100 * percent );
// Show the control.
editorService.DropDownControl( trackBar );
// Here is the output value.
value = valueLow + ( (double)trackBar.Value / 100 ) * ( valueHigh - valueLow );
}
}
return value;
}
public override object EditValue(ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
if (context != null && provider != null)
{
edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
lb = new ListBox();
lb.Items.AddRange(new object[] {
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday"});
lb.SelectedIndexChanged += new System.EventHandler(lb_SelectedIndexChanged);
edSvc.DropDownControl(lb);
}
return text;
}
return base.EditValue(context, provider, value);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context!=null && context.Instance!=null && provider!=null)
{
m_EdSvc=(IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if(m_EdSvc!=null)
{
ShortcutsListBox lst=null;
if(context.Instance is BaseItem)
lst=new ShortcutsListBox(((BaseItem)context.Instance).Shortcuts);
else if (context.Instance is ButtonX)
lst = new ShortcutsListBox(((ButtonX)context.Instance).Shortcuts);
else if(context.Instance is DotNetBarManager)
lst=new ShortcutsListBox(((DotNetBarManager)context.Instance).AutoDispatchShortcuts);
else if(context.Instance!=null)
System.Windows.Forms.MessageBox.Show("Unknow control using shortcuts. Cannot edit shortcuts. ["+context.Instance.ToString()+"]");
else
System.Windows.Forms.MessageBox.Show("Unknow control using shortcuts. Cannot edit shortcuts. [context instance null]");
if(lst!=null)
{
m_EdSvc.DropDownControl(lst);
value=lst.Shortcuts();
((ShortcutsCollection)value).Parent=context.Instance as BaseItem;
}
}
}
return value;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null
&& context.Instance != null
&& provider != null)
{
m_EditorService = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
if (m_EditorService != null)
{
TextMarkupEditor editor = new TextMarkupEditor();
editor.buttonOK.Click += new EventHandler(MarkupEditorButtonClick);
editor.buttonCancel.Click += new EventHandler(MarkupEditorButtonClick);
if(value!=null)
editor.inputText.Text = value.ToString();
m_EditorService.DropDownControl(editor);
if (editor.DialogResult == DialogResult.OK)
{
string text = editor.inputText.Text;
editor.Dispose();
return text;
}
editor.Dispose();
}
}
return value;
}
/// <summary>
/// Edits a value based on some user input which is collected from a character control.
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
_dialogProvider = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
List<int> layerList = new List<int>();
LayoutLegend legend = context.Instance as LayoutLegend;
LayoutMap map = null;
if (legend != null)
map = legend.Map;
if (map == null)
return layerList;
CheckedListBox lb = new CheckedListBox();
List<int> originalList = value as List<int>;
if (originalList != null)
{
for (int i = map.MapControl.Layers.Count - 1; i >= 0 ; i--)
lb.Items.Add(map.MapControl.Layers[i].LegendText, originalList.Contains(i));
}
_dialogProvider.DropDownControl(lb);
for (int i = 0; i < lb.Items.Count; i ++)
{
if (lb.GetItemChecked(i))
layerList.Add(lb.Items.Count - 1 -i);
}
return layerList;
}
/// <summary>
/// Called when we want to edit the value of a property.
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
UI.Actions.MessageAction messageAction = context.Instance as UI.Actions.MessageAction;
if (messageAction != null)
{
ListBox listBox = new ListBox();
foreach (UI.Message message in messageAction.Scene.Messages)
{
listBox.Items.Add(message);
}
listBox.SelectedItem = messageAction.Scene.GetMessage((int)value);
listBox.SelectedIndexChanged += ((s, e) => { edSvc.CloseDropDown(); });
edSvc.DropDownControl(listBox);
return listBox.SelectedItem != null ? (listBox.SelectedItem as UI.Message).ID : -1;
}
}
return value;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
fes = (IWindowsFormsEditorService) provider.GetService(typeof (IWindowsFormsEditorService));
if (fes == null)
{
return value;
}
var lb = new ListBox {Sorted = true, SelectionMode = SelectionMode.One, HorizontalScrollbar = true};
foreach (string lang in LanguageHolder.Instance().Languages)
{
lb.Items.Add(lang);
}
int index = lb.Items.IndexOf(RConfig.Instance.Language);
lb.SelectedIndex = index == -1 ? 0 : index;
if (value != null)
{
index = lb.Items.IndexOf(value);
if (index > 0)
lb.SelectedIndex = index;
}
lb.SelectedIndexChanged += lb_SelectedIndexChanged;
fes.DropDownControl(lb);
return lb.SelectedItem.ToString();
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
editorService = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
if (editorService == null)
return value;
FmodEventShape Shape = context.Instance as FmodEventShape;
System.Diagnostics.Debug.Assert(Shape != null, "EventGroupSelectionEditor only valid for FmodEventShapes!");
// Create a TreeView and populate it
treeView = new TreeView();
treeView.ImageList = EditorManager.GUI.ShapeTreeImages.ImageList;
treeView.Bounds = new Rectangle(0, 0, 400, 500);
treeView.NodeMouseClick += new System.Windows.Forms.TreeNodeMouseClickEventHandler(this.treeView_NodeMouseClick);
FmodManaged.ManagedModule.GetEventGroupTree(Shape.EventProject, treeView);
treeView.ExpandAll();
// Show our listbox as a DropDownControl.
// This methods returns, when the DropDownControl is closed.
editorService.DropDownControl(treeView);
TreeNode selectedNode = treeView.SelectedNode;
if (selectedNode != null)
{
string fullPath = selectedNode.FullPath;
return fullPath.Replace("\\", "/");
}
else
return Shape.EventGroup;
}
/// <summary>
/// Called when we want to edit the value of the property. Brings up the a drop down list box of masks.
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
GUIControl controlContext = context.Instance as GUIControl;
ListBox listBox = new ListBox();
listBox.Items.Add("None");
AddControls(listBox, controlContext.ParentView.Controls);
listBox.SelectedItem = value;
listBox.SelectedIndexChanged += (s, e) => { edSvc.CloseDropDown(); };
edSvc.DropDownControl(listBox);
//no valid item selected; return previous value
if (listBox.SelectedIndex == -1 || listBox.SelectedItem == null)
return value;
//"None" selected
if (listBox.SelectedIndex == 0)
return -1;
return (listBox.SelectedItem as GUIMask).ID;
}
return value;
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (provider != null)
{
service = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (service != null)
{
ListBox list = new ListBox();
list.Click += new EventHandler(list_Click);
foreach (Cause c in causeList)
{
list.Items.Add(c);
}
service.DropDownControl(list);
if (list.SelectedItem != null && list.SelectedIndices.Count == 1)
{
value = list.SelectedItem;
}
}
}
return value;
}
/// <summary>
/// This takes care of the actual value-change of the property.
/// </summary>
/// <param name="itdc">Standard ITypeDescriptorContext object.</param>
/// <param name="isp">Standard IServiceProvider object.</param>
/// <param name="value">The value as an object.</param>
/// <returns>The new value as an object.</returns>
public override object EditValue(ITypeDescriptorContext itdc, IServiceProvider isp, object value)
{
if(itdc != null && itdc.Instance != null && isp != null)
{
iwfes = (IWindowsFormsEditorService)isp.GetService(typeof(IWindowsFormsEditorService));
if(iwfes != null)
{
MWCommon.TextDir td = MWCommon.TextDir.Normal;
if(value is MWCommon.TextDir)
{
td = (MWCommon.TextDir)itdc.PropertyDescriptor.GetValue(itdc.Instance);
pd = itdc.PropertyDescriptor;
oInstance = itdc.Instance;
}
EditorTextDirUI etdui = new EditorTextDirUI();
etdui.IWFES = iwfes;
etdui.ITDC = itdc;
etdui.TextDir = (MWCommon.TextDir)value;
etdui.TextDirChanged += new EditorTextDirUI.TextDirEventHandler(this.ValueChanged);
iwfes.DropDownControl(etdui);
value = etdui.TextDir;
}
}
return value;
}
/// <summary>
/// This takes care of the actual value-change of the property.
/// </summary>
/// <param name="itdc">Standard ITypeDescriptorContext object.</param>
/// <param name="isp">Standard IServiceProvider object.</param>
/// <param name="value">The value as an object.</param>
/// <returns>The new value as an object.</returns>
public override object EditValue(ITypeDescriptorContext itdc, IServiceProvider isp, object value)
{
if(itdc != null && itdc.Instance != null && isp != null)
{
iwfes = (IWindowsFormsEditorService)isp.GetService(typeof(IWindowsFormsEditorService));
if(iwfes != null)
{
HatchStyle hs = HatchStyle.Weave;
//if(itdc.PropertyDescriptor.GetValue(itdc.Instance) is HatchStyle)
if(value is HatchStyle)
{
hs = (HatchStyle)itdc.PropertyDescriptor.GetValue(itdc.Instance);
pd = itdc.PropertyDescriptor;
oInstance = itdc.Instance;
}
//EditorHatchStyleUI ehsui = new EditorHatchStyleUI(hs, Color.White, Color.Black); //FIX THIS XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
EditorHatchStyleUI ehsui = new EditorHatchStyleUI(HatchStyle.Trellis, Color.White, Color.Black);
ehsui.IWFES = iwfes;
ehsui.ITDC = itdc;
ehsui.HatchStyle = (HatchStyle)value;
ehsui.HatchStyleChanged += new EditorHatchStyleUI.MWHatchStyleEventHandler(ValueChanged);
iwfes.DropDownControl(ehsui);
value = ehsui.HatchStyle;
}
}
return value;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
wfes = (IWindowsFormsEditorService) provider.GetService(typeof (IWindowsFormsEditorService));
if ((wfes == null) || (context == null))
return null;
ImageList imageList = GetImageList(context.Instance);
if ((imageList == null) || (imageList.Images.Count == 0))
return -1;
m_imagePanel = new ImageListPanel();
m_imagePanel.BackgroundColor = Color.FromArgb(241, 241, 241);
m_imagePanel.BackgroundOverColor = Color.FromArgb(102, 154, 204);
m_imagePanel.HLinesColor = Color.FromArgb(182, 189, 210);
m_imagePanel.VLinesColor = Color.FromArgb(182, 189, 210);
m_imagePanel.BorderColor = Color.FromArgb(0, 0, 0);
m_imagePanel.EnableDragDrop = true;
m_imagePanel.Init(imageList, 12, 12, 6, (int) value);
// add listner for event
m_imagePanel.ItemClick += OnItemClicked;
// set m_selectedIndex to -1 in case the dropdown is closed without selection
m_selectedIndex = -1;
// show the popup as a drop-down
wfes.DropDownControl(m_imagePanel);
// return the selection (or the original value if none selected)
return (m_selectedIndex != -1) ? m_selectedIndex : (int) value;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (value == null)
{
value = Hues.GetHue(0);
}
if (value.GetType() == typeof(Hue))
{
editorService = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (editorService == null)
{
return value;
}
HuePickerControl control = new HuePickerControl((Hue)value);
control.ValueChanged += new HuePickerControl.ValueChangedEventHandler(this.ValueSelected);
editorService.DropDownControl(control);
if (returnValue != null)
{
control.Dispose();
return returnValue;
}
control.Dispose();
}
return value;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null
&& context.Instance != null
&& provider != null)
{
edSvc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
if (edSvc != null)
{
ListBox lb = new ListBox();
lb.SelectedIndexChanged += new EventHandler(this.SelectedChanged);
MetroColorGeneratorParameters currentParams = (MetroColorGeneratorParameters)value;
MetroColorGeneratorParameters[] metroThemes = MetroColorGeneratorParameters.GetAllPredefinedThemes();
string selectedTheme = null;
foreach (MetroColorGeneratorParameters mt in metroThemes)
{
lb.Items.Add(mt.ThemeName);
if (currentParams.BaseColor == mt.BaseColor && currentParams.CanvasColor == mt.CanvasColor)
{
lb.SelectedItem = mt.ThemeName;
selectedTheme = mt.ThemeName;
}
}
edSvc.DropDownControl(lb);
if (lb.SelectedItem != null && selectedTheme != (string)lb.SelectedItem)
{
return metroThemes[lb.SelectedIndex];
}
}
}
return value;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
try
{
Box1.Items.Clear();
if(ItemList != null)
{
Box1.Items.AddRange(ItemList);
}else
{
Box1.Items.Clear();
}
Box1.Height = Box1.PreferredHeight;
srvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if(srvc != null)
{
srvc.DropDownControl(Box1);
ItemList = null;
return Box1.SelectedItem.ToString();
}
}
catch
{
}
return value;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null
&& context.Instance != null
&& provider != null)
{
edSvc = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
if (edSvc != null)
{
ListBox lb = new ListBox();
lb.SelectedIndexChanged += new EventHandler(this.SelectedChanged);
Type t = typeof(ElementStyleClassKeys);
FieldInfo[] fields = t.GetFields(BindingFlags.Public | BindingFlags.Static);
foreach (FieldInfo pi in fields)
{
string s = pi.GetValue(null).ToString();
lb.Items.Add(s);
if (s == value.ToString())
lb.SelectedItem = s;
}
edSvc.DropDownControl(lb);
if (lb.SelectedItem != null)
return lb.SelectedItem.ToString();
}
}
return value;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null
&& context.Instance != null
&& provider != null)
{
ElementStyle es = value as ElementStyle;
_EditorService = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
if (_EditorService != null)
{
ListBox lb = new ListBox();
List<DevComponents.Schedule.TimeZoneInfo> timeZonesList = DevComponents.Schedule.TimeZoneInfo.GetSystemTimeZones();
int selectedIndex = -1;
for (int i = 0; i < timeZonesList.Count; i++)
{
DevComponents.Schedule.TimeZoneInfo timeZoneInfo = timeZonesList[i];
lb.Items.Add(timeZoneInfo.Id);
if (timeZoneInfo.Id.Equals((string)value))
selectedIndex = i;
}
lb.SelectedIndex = selectedIndex;
lb.SelectedIndexChanged += new EventHandler(this.SelectedChanged);
_EditorService.DropDownControl(lb);
return lb.SelectedItem;
}
}
return value;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null
&& context.Instance != null
&& provider != null)
{
m_EditorService = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
if(m_EditorService!=null)
{
ListBox lb=new ListBox();
object dotNetBarManager=null;
lb.SelectedIndexChanged+=new EventHandler(this.SelectedChanged);
IDesignerHost host = (IDesignerHost)provider.GetService(typeof(IDesignerHost));
foreach(IComponent component in host.Container.Components)
{
if(component is ContextMenu || component.GetType().FullName=="System.Windows.Forms.ContextMenuStrip")
{
lb.Items.Add(component);
}
if(component.GetType().FullName=="DevComponents.DotNetBar.DotNetBarManager")
{
dotNetBarManager=component;
IList contextMenus=component.GetType().InvokeMember("ContextMenus",
System.Reflection.BindingFlags.GetProperty, null, component, null) as IList;
if(contextMenus!=null)
{
foreach(object o in contextMenus)
{
string name=o.GetType().InvokeMember("Name", System.Reflection.BindingFlags.GetProperty, null, o, null).ToString();
if(name!=null)
{
lb.Items.Add(DotNetBarPrefix+name);
}
}
}
}
}
m_EditorService.DropDownControl(lb);
if(lb.SelectedItem!=null)
{
if(lb.SelectedItem.ToString().StartsWith(DotNetBarPrefix))
{
Node node=context.Instance as Node;
if(node!=null && node.TreeControl!=null)
{
TypeDescriptor.GetProperties(node.TreeControl)["DotNetBarManager"].SetValue(node.TreeControl, dotNetBarManager);
}
}
return lb.SelectedItem;
}
}
}
return value;
}
/// <summary>
/// Edits a value based on some user input which is collected from a character control.
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
_dialogProvider = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
AngleControl ac = new AngleControl { Angle = Convert.ToInt32(value) };
ac.AngleChosen += AcAngleChosen;
if (_dialogProvider != null) _dialogProvider.DropDownControl(ac);
return (double)ac.Angle;
}
/// <summary>
/// Edits a value based on some user input which is collected from a character control.
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
_dialogProvider = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
AngleControl ac = new AngleControl();
ac.Angle = Convert.ToInt32(value);
ac.AngleChosen += new EventHandler(ac_AngleChosen);
_dialogProvider.DropDownControl(ac as System.Windows.Forms.Control);
return (object)(double)ac.Angle;
}
/// <summary>
/// Edits a value based on some user input which is collected from a character control.
/// </summary>
/// <param name="context">The type descriptor context.</param>
/// <param name="provider">The service provider.</param>
/// <param name="value">Not used.</param>
/// <returns>Returns the selected character.</returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
ICharacterSymbol symbol = context?.Instance as ICharacterSymbol;
IWindowsFormsEditorService dialogProvider = provider?.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
CharacterControl cc = new(dialogProvider, symbol);
dialogProvider?.DropDownControl(cc);
return(cc.SelectedChar);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null
&& context.Instance != null
&& provider != null)
{
ValidatorBase es = value as ValidatorBase;
_EditorService = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
if (_EditorService != null)
{
ListBox list = new ListBox();
list.Items.Add("(none)");
list.Items.Add("Required Field Validator");
list.Items.Add("Regular Expression Validator");
list.Items.Add("Compare Fields Validator");
list.Items.Add("Range Validator");
list.Items.Add("Custom Code Validator");
list.SelectedIndexChanged += new EventHandler(ValidatorListSelectedIndexChanged);
_EditorService.DropDownControl(list);
int listSelectedIndex = list.SelectedIndex;
if (listSelectedIndex > 0)
{
listSelectedIndex--;
Type validatorType = null;
if (listSelectedIndex == 1)
validatorType = typeof(RegularExpressionValidator);
else if (listSelectedIndex == 2)
validatorType = typeof(CompareValidator);
else if (listSelectedIndex == 3)
validatorType = typeof(RangeValidator);
else if (listSelectedIndex == 4)
validatorType = typeof(CustomValidator);
else
validatorType = typeof(RequiredFieldValidator);
IDesignerHost dh = provider.GetService(typeof(IDesignerHost)) as IDesignerHost;
if (dh != null)
{
ValidatorBase val = dh.CreateComponent(validatorType) as ValidatorBase;
val.HighlightColor = eHighlightColor.Red;
val.ErrorMessage = "Your error message here.";
return val;
}
}
else
return null;
}
return es;
}
return null;
}
/// <summary>
/// Display a drop down when editing instead of the normal control, and allow the user to "grab" a
/// new dynamic visibility extent.
/// </summary>
/// <param name="context">The type descriptor context.</param>
/// <param name="provider">The service provider.</param>
/// <param name="value">Not used.</param>
/// <returns>Returns whether or not to use the dynamic visibility.</returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
_layer = context?.Instance as ILayer;
IWindowsFormsEditorService dialogProvider = provider?.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
DynamicVisibilityControl dvc = new DynamicVisibilityControl(dialogProvider, _layer);
dialogProvider?.DropDownControl(dvc);
_layer?.Invalidate();
return(dvc.UseDynamicVisibility);
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, IServiceProvider provider, object value)
{
_value = (Color)value;
edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
edSvc.DropDownControl(_c);
value = _value;
return base.EditValue(context, provider, value);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
es = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (es == null) return null;
var transp = (int)value;
ctrlTransp.Transparency = transp;
es.DropDownControl(ctrlTransp);
return ctrlTransp.Transparency;
}
/// <inheritdoc/>
protected override float EditValue(float value, IWindowsFormsEditorService editorService)
{
#region Sanity checks
if (editorService == null) throw new ArgumentNullException(nameof(editorService));
#endregion
var angleControl = new AngleControl {Angle = value};
editorService.DropDownControl(angleControl);
return angleControl.Angle;
}
/// <summary>
/// Edits the value of the specified object using the editor style indicated by GetEditStyle.
/// </summary>
/// <param name="context">An ITypeDescriptorContext that can be used to gain additional context information.</param>
/// <param name="provider">An IServiceProvider that this editor can use to obtain services.</param>
/// <param name="value">The object to edit.</param>
/// <returns>The new value of the object.</returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null && context.Instance != null && provider != null)
{
m_EditorService = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
ColorScheme cs=null;
if(context.Instance!=null)
{
MethodInfo method=context.Instance.GetType().GetMethod("GetColorScheme",BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
if(method!=null)
{
cs=method.Invoke(context.Instance,null) as ColorScheme;
}
}
Color colorValue=(Color)value;
if(m_EditorService!=null)
{
ColorPicker colorPicker=new ColorPicker();
colorPicker.EditorService=m_EditorService;
colorPicker.BackColor=SystemColors.Control;
colorPicker.ColorScheme=cs;
colorPicker.SelectedColor=colorValue;
string propertyName=context.PropertyDescriptor.Name;
PropertyInfo property=context.Instance.GetType().GetProperty(propertyName+"SchemePart",BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
if(property!=null)
{
colorPicker.SelectedColorSchemeName=property.GetValue(context.Instance,null).ToString();
}
colorPicker.UpdateUIWithSelection();
m_EditorService.DropDownControl(colorPicker);
if(!colorPicker.Canceled)
{
Color returnColor=colorPicker.SelectedColor;
eColorSchemePart schemePart=eColorSchemePart.None;
if(colorPicker.SelectedColorSchemeName!="")
{
schemePart=(eColorSchemePart)Enum.Parse(typeof(eColorSchemePart),colorPicker.SelectedColorSchemeName);
}
if(property!=null)
{
property.SetValue(context.Instance,schemePart,null);
}
return returnColor;
}
}
}
return value;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
es = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (es == null) return null;
indi = (IChartIndicator)context.Instance;
LoadListBoxItems();
es.DropDownControl(cbx);
return value;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
_edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (_edSvc == null)
{
return null;
}
_edSvc.DropDownControl(_box);
return _box.SelectedItem;
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value) {
service = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (service != null) {
ConfigureListBox();
SetSelection((WorkitemPropertyDescriptor)context.PropertyDescriptor, value);
service.DropDownControl(ListBox);
return GetSelection();
}
return value;
}
/// <summary>
/// Edits a value based on some user input which is collected from a character control.
/// </summary>
/// <param name="context">The type descriptor context.</param>
/// <param name="provider">The service provider.</param>
/// <param name="value">The angle value.</param>
/// <returns>The angle.</returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
_dialogProvider = provider?.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
AngleControl ac = new()
{
Angle = Convert.ToInt32(value)
};
ac.AngleChosen += AcAngleChosen;
_dialogProvider?.DropDownControl(ac);
return((double)ac.Angle);
}
// Displays the UI for value selection.
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
// Uses the IWindowsFormsEditorService to display a
// drop-down UI in the Properties window.
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
// Display an angle selection control and retrieve the value.
TileControl idControl = new TileControl((ushort)value, edSvc);
edSvc.DropDownControl(idControl);
return(idControl.value);
}
return(value);
}
/// <summary>
/// Edits a value regarding a given service provider under a specified context.
/// </summary>
/// <param name="context">Context informations.</param>
/// <param name="provider">Service provider.</param>
/// <param name="value">Value to be edited.</param>
/// <returns>The edited value.</returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null && context.Instance != null && provider != null)
{
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
Enum e = (Enum)Convert.ChangeType(value, context.PropertyDescriptor.PropertyType);
_listBox.EnumValue = e;
edSvc.DropDownControl(_listBox);
return(_listBox.EnumValue);
}
}
return(null);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
_editorService = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
TextBox textEditorBox = new TextBox();
textEditorBox.Multiline = true;
textEditorBox.ScrollBars = ScrollBars.Vertical;
textEditorBox.Width = 250;
textEditorBox.Height = 150;
textEditorBox.BorderStyle = BorderStyle.None;
textEditorBox.AcceptsReturn = true;
textEditorBox.Text = value as string;
_editorService.DropDownControl(textEditorBox);
return(textEditorBox.Text);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
es = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (es == null)
{
return(null);
}
indi = (IChartIndicator)context.Instance;
LoadItems();
lb.Sorted = true;
es.DropDownControl(lb);
return(value);
}
public override dynamic EditValue(System.ComponentModel.ITypeDescriptorContext context, IServiceProvider provider, object value)
{
frmsvr = (IWindowsFormsEditorService)(provider.GetService(typeof(IWindowsFormsEditorService)));
if (ReferenceEquals(frmsvr, null))
{
return(null);
}
ListBox lstbox = new ListBox();
lstbox.Items.AddRange(MemoryName);
lstbox.SelectedIndex = 0;
lstbox.SelectedIndexChanged += ListBox1SelectedIndexChanged;
frmsvr.DropDownControl(lstbox);
return(MemoryValue[lstbox.SelectedIndex]);
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, IServiceProvider provider, object value)
{
_svc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (_svc != null)
{
var inDate = DateTime.FromBinary((long)((int)value));
_calendar.SetDate(inDate);
_svc.DropDownControl(_calendar);
var outDate = _calendar.SelectionStart;
value = (int)outDate.ToBinary();
}
return(value);
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context,
System.IServiceProvider provider, object value)
{
IWindowsFormsEditorService edSvc =
(IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
VehicleTypeControl vehicleTypeControl = new VehicleTypeControl((TypeOfVehicle)value);
vehicleTypeControl.Size = vehicleTypeControl.Image.Size;
edSvc.DropDownControl(vehicleTypeControl);
return(vehicleTypeControl.CurrentType);
}
return(value);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc == null)
{
return(value);
}
// Displays a drop-down control.
Control inputControl = new PathEditorControl((string)value, edSvc);
edSvc.DropDownControl(inputControl);
return(((PathEditorControl)inputControl).inputTextBox.Text);
// return base.EditValue(context, provider, value);
}
/// <inheritdoc/>
protected override float EditValue(float value, IWindowsFormsEditorService editorService)
{
#region Sanity checks
if (editorService == null)
{
throw new ArgumentNullException(nameof(editorService));
}
#endregion
var angleControl = new AngleControl {
Angle = value
};
editorService.DropDownControl(angleControl);
return(angleControl.Angle);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
IWindowsFormsEditorService wfes = provider.GetService(
typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
if (wfes != null)
{
gView.Framework.Symbology.UI.Controls.OfficeColorPicker picker = new gView.Framework.Symbology.UI.Controls.OfficeColorPicker(wfes, (Color)value);
picker.AllowNoColor = true;
picker.Height = picker.PreferredHeight;
wfes.DropDownControl(picker);
return(picker.Color);
}
return(value);
}
/// <summary>
/// Edits the given value.
/// </summary>
/// <param name="context">The context that provides information about the editing.</param>
/// <param name="provider">The provider to use to get required services.</param>
/// <param name="value">The value to edit.</param>
/// <returns>The edited value.</returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null && context.Instance != null && provider != null)
{
IWindowsFormsEditorService wesEditor = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (wesEditor != null)
{
Enum e = (Enum)Convert.ChangeType(value, context.PropertyDescriptor.PropertyType);
m_clbFlagEnum.EnumValue = e;
wesEditor.DropDownControl(m_clbFlagEnum);
return(m_clbFlagEnum.EnumValue);
}
}
return(null);
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
ColorListBox ColorControl = new ColorListBox(edSvc);
edSvc.DropDownControl(ColorControl);
if (ColorControl.Text != string.Empty)
{
value = ColorControl.Text;
}
}
return(value);
}
/// <summary>
/// Edits a value based on some user input which is collected from a character control.
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
_dialogProvider = provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService;
AngleControl ac = new AngleControl();
ac.StartAngle = 90;
ac.Clockwise = true;
ac.Angle = Convert.ToInt32(value);
ac.AngleChosen += AcAngleChosen;
if (_dialogProvider != null)
{
_dialogProvider.DropDownControl(ac);
}
return((double)ac.Angle);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider sp, object value)
{
if (m_ui == null)
{
m_ui = new DockAreasEditor.DockAreasEditorControl();
}
m_ui.SetStates((DockAreas)value);
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)sp.GetService(typeof(IWindowsFormsEditorService));
edSvc.DropDownControl(m_ui);
return(m_ui.DockAreas);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
EditorFilter filter = (EditorFilter)context.PropertyDescriptor.Attributes[typeof(EditorFilter)];
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc == null)
{
return(value);
}
ui_file_get_editor inputControl = new ui_file_get_editor(filter.Filter, (string)value, edSvc, false);
edSvc.DropDownControl(inputControl);
return(inputControl.TempValue == null?value:inputControl.TempValue);
// return base.EditValue(context, provider, value);
}
public override object EditValue(ITypeDescriptorContext context,
IServiceProvider provider, object value)
{
IWindowsFormsEditorService wfes = (IWindowsFormsEditorService)provider.GetService(
typeof(IWindowsFormsEditorService));
if (wfes == null || context == null)
{
return(null);
}
ImageList imageList = null;
Component component = (Component)context.Instance;
IExtenderListService extenderListService = (IExtenderListService)component.Site.GetService(typeof(IExtenderListService));
if (extenderListService != null)
{
IExtenderProvider[] extenders = extenderListService.GetExtenderProviders();
for (int i = 0; i < extenders.Length; i++)
{
if (extenders[i].GetType().FullName == "MenuExtender.MenuExtender")
{
MenuExtender menuExtender = (MenuExtender)extenders[i];
imageList = menuExtender.ImageList;
}
}
}
ImageSelector imageSelector = new ImageSelector(imageList, (int)value, wfes);
wfes.DropDownControl(imageSelector);
int imageIndex = -1;
if (imageSelector.SelectedItems.Count != 0)
{
try
{
imageIndex = (int)Convert.ToInt32(imageSelector.SelectedItems[0].Text);
}
catch
{
imageIndex = -1;
}
}
return(imageIndex);
}
public override object EditValue(ITypeDescriptorContext typeDescriptorContext, IServiceProvider serviceProvider, object value)
{
if (typeDescriptorContext == null)
{
throw new ArgumentNullException("typeDescriptorContext");
}
if (serviceProvider == null)
{
throw new ArgumentNullException("serviceProvider");
}
_editorService = (IWindowsFormsEditorService)serviceProvider.GetService(typeof(IWindowsFormsEditorService));
_context = typeDescriptorContext;
// Initialize the dropdown control
ListBox dropDownList = new ListBox();
dropDownList.BorderStyle = BorderStyle.None;
Activity activity = _context.Instance as Activity;
if (activity == null)
{
// this could happen when there are multiple
// SetState activities selected
object[] activities = _context.Instance as object[];
if (activities != null && activities.Length > 0)
{
activity = (Activity)activities[0];
}
}
Debug.Assert(activity != null);
// Add the items from the typeconverter, followed by the datasource choices
PopulateDropDownList(dropDownList, activity);
dropDownList.SelectedIndexChanged += new EventHandler(dataSourceDropDown_SelectedIndexChanged);
// Display the control
_editorService.DropDownControl(dropDownList);
// If a value was selected, read the selected value from the control and return it
if (dropDownList.SelectedIndex != -1 && _selectedObject != null)
{
return(_selectedObject);
}
return(value);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null && context.Instance != null && provider != null)
{
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
FieldEditorList felst = context.Instance as FieldEditorList;
if (felst != null)
{
DataEditorListBox list = new DataEditorListBox(edSvc);
edSvc.DropDownControl(list);
if (list.Selector != null)
{
if (list.Selector is DataEditorNone)
{
value = null;
felst.RemoveEditorByName(context.PropertyDescriptor.Name);
}
else
{
list.Selector.ValueField = context.PropertyDescriptor.Name;
list.Selector.SetFieldsAttribute(felst.Fields);
DataEditor current = value as DataEditor;
DlgSetEditorAttributes dlg = list.Selector.GetDataDialog(current);
if (dlg != null)
{
if (edSvc.ShowDialog(dlg) == DialogResult.OK)
{
dlg.SelectedEditor.ValueField = context.PropertyDescriptor.Name;
current = (DataEditor)dlg.SelectedEditor.Clone();
value = current;
felst.AddEditor(current);
}
}
else
{
current = (DataEditor)list.Selector.Clone();
value = list.Selector;
felst.AddEditor(current);
}
}
}
}
}
}
return(value);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (context != null && context.Instance != null && provider != null)
{
IWindowsFormsEditorService editorService = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (editorService != null)
{
EditorControlBase control = CreateEditorControl(context, provider, editorService);
control.Value = value;
editorService.DropDownControl(control);
value = control.Value;
}
}
return(value);
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
IWindowsFormsEditorService edSvc =
(IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
string content = (value as ISupportJsonSerialization).ToJsonString();
object tempObject = (value as ISupportJsonSerialization).ParseJsonObject(content);
control.SetSingle(tempObject);
edSvc.DropDownControl(control);
return(control.GetSingle());
}
return(value);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (provider != null)
{
editorService = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
}
if (editorService != null)
{
HotKeyWrapperControl hotKeyWrapperControl = new HotKeyWrapperControl(editorService);
editorService.DropDownControl(hotKeyWrapperControl);
value = hotKeyWrapperControl.Result;
}
return(value);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
windowsFormsEditorService = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
FillValues(ServiceHelper.GetExtensionProviderService(context).ExtensionProviders, context);
windowsFormsEditorService.DropDownControl(this.control);
if (this.control.SelectedItems.Count == 1)
{
value = this.control.SelectedItems[0].Tag;
ExtendModelElements(context, value);
}
return(value);
}
public override object EditValue(ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
if (context != null && context.Instance != null && provider != null)
{
IWindowsFormsEditorService editorService = provider.GetService(
typeof(IWindowsFormsEditorService))
as IWindowsFormsEditorService;
if (editorService != null)
{
CornerSelector cs = new CornerSelector(value);
editorService.DropDownControl(cs);
value = cs.BorderCorners;
}
}
return(value);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
if (value.GetType() != typeof(uint))
{
return(value);
}
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc != null)
{
PropertyPaletteControl prop = new PropertyPaletteControl((uint)value);
edSvc.DropDownControl(prop);
return(prop.result);
}
return(value);
}
/// <summary>
/// Displays test parameters dialog for edit from properties window.
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
IWindowsFormsEditorService wfservice = provider.GetService(typeof(IWindowsFormsEditorService))
as IWindowsFormsEditorService;
RichTextBox textBox = new RichTextBox();
textBox.Text = value as string;
textBox.BorderStyle = BorderStyle.None;
textBox.Multiline = true;
textBox.Size = new System.Drawing.Size(20, 80);
//textBox.BackColor = System.Drawing.Color.AliceBlue;
textBox.LinkClicked += textBox_LinkClicked;
wfservice.DropDownControl(textBox);
return(textBox.Text);
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, IServiceProvider provider, object value)
{
edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
imagesContainer.ImageList = imageList;
if (edSvc != null)
{
edSvc.DropDownControl(imagesContainer);
if (imagesContainer.SelectedItem != string.Empty)
{
return(imagesContainer.SelectedItem.ToString());
}
}
return(value);
}
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value)
{
// Attempts to obtain an IWindowsFormsEditorService.
IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
if (edSvc == null)
{
return(value);
}
// Displays a drop-down control.
StringInputControl inputControl = new StringInputControl((string)value, edSvc);
edSvc.DropDownControl(inputControl);
return(inputControl.inputTextBox.Text);
}