Exemple #1
0
        /// <include file='doc\QueuePathEditor.uex' path='docs/doc[@for="PropertyBindingEditor.EditValue"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {
            if (provider != null)
            {
                IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
                if (edSvc != null)
                {
                    PropertyBinding binding = value as PropertyBinding;
                    if (binding != null)
                    {
                        PropertyBinding     bindingToEdit = new PropertyBinding(binding);
                        SingleBindingDialog bindingUI     = new SingleBindingDialog(bindingToEdit);
                        if (edSvc.ShowDialog(bindingUI) == DialogResult.OK)
                        {
                            value = bindingToEdit;

                            ManagedPropertiesService svc = (ManagedPropertiesService)context.GetService(typeof(ManagedPropertiesService));
                            if (svc != null)
                            {
                                svc.MakeDirty();
                                try {
                                    svc.WriteConfigFile();
                                }
                                catch {
                                }
                            }
                        }
                    }
                }
            }

            return(value);
        }
 public BindingData(PropertyBinding binding)
 {
     this.Name  = binding.Property.Name;
     this.Key   = binding.Key;
     this.Bound = binding.Bound;
     this.Value = binding;
 }
        private void CreateBindings()
        {
            bindings = new PropertyBindingCollection();
            ManagedPropertiesService svc = (ManagedPropertiesService)component.Site.GetService(typeof(ManagedPropertiesService));

            if (svc != null)
            {
                PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(component, new Attribute[] { BrowsableAttribute.Yes });
                for (int i = 0; i < properties.Count; i++)
                {
                    PropertyDescriptor prop = properties[i];

                    if (prop.DesignTimeOnly)
                    {
                        continue;
                    }
                    if (prop.IsReadOnly)
                    {
                        continue;
                    }
                    if (prop.Attributes.Contains(DesignerSerializationVisibilityAttribute.Hidden))
                    {
                        continue;
                    }
                    // don't show the ComponentSettings property - it can't be managed!
                    if (prop.PropertyType == typeof(ComponentSettings))
                    {
                        continue;
                    }
                    if (!ManagedPropertiesService.IsTypeSupported(prop.PropertyType))
                    {
                        continue;
                    }

                    PropertyBinding binding = svc.Bindings[component, prop];
                    if (binding == null)
                    {
                        binding           = new PropertyBinding(host);
                        binding.Component = component;
                        binding.Property  = prop;
                        binding.Reset();
                    }
                    else
                    {
                        binding = (PropertyBinding)binding.Clone();
                    }
                    bindings.Add(binding);
                }
            }
        }
Exemple #4
0
        /// <include file='doc\PropertyBinding.uex' path='docs/doc[@for="PropertyBinding.PropertyBinding1"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public PropertyBinding(PropertyBinding bindingToClone)
        {
            if (bindingToClone != null)
            {
                bound         = bindingToClone.bound;
                enabled       = bindingToClone.enabled;
                componentName = bindingToClone.componentName;
                property      = bindingToClone.property;
                key           = bindingToClone.key;
                host          = bindingToClone.host;

                component = bindingToClone.component;
                isDefault = bindingToClone.isDefault;
            }
        }
        /// <include file='doc\BindingPropertyDescriptor.uex' path='docs/doc[@for="BindingPropertyDescriptor.GetValue"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public override object GetValue(object component)
        {
            PropertyBinding binding = compSettings.Bindings[compSettings.Component, property];

            if (binding == null)
            {
                // this will only happen if the property was "recommended" but it had never
                // been bound.
                binding           = new PropertyBinding(GetHost());
                binding.Component = compSettings.Component;
                binding.Property  = property;
                binding.Reset();
                compSettings.Bindings[compSettings.Component, property] = binding;
            }
            return(binding);
        }
Exemple #6
0
        /// <include file='doc\PropertyBindingConverter.uex' path='docs/doc[@for="PropertyBindingConverter.ConvertTo"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
        {
            if (destinationType == typeof(string) && value is PropertyBinding)
            {
                if (value == null)
                {
                    return(SR.GetString(SR.ConfigNone));
                }
                PropertyBinding binding = (PropertyBinding)value;
                if (!binding.Bound)
                {
                    return(SR.GetString(SR.ConfigNone));
                }

                return(binding.Key);
            }
            else
            {
                return(base.ConvertTo(context, culture, value, destinationType));
            }
        }
        /// <include file='doc\ComponentSettingsConverter.uex' path='docs/doc[@for="ComponentSettingsConverter.GetProperties"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
        {
            ComponentSettings         compSettings = (ComponentSettings)value;
            PropertyBindingCollection bindings     = compSettings.Bindings.GetBindingsForComponent(compSettings.Component);

            ArrayList props = new ArrayList();

            // go through all the properties on the component and see if they have the "show me" attribute.
            // also check to see if the propert has already been bound.
            IComponent    component = compSettings.Component;
            IDesignerHost host      = (IDesignerHost)component.Site.GetService(typeof(IDesignerHost));
            PropertyDescriptorCollection componentProps = TypeDescriptor.GetProperties(component);

            for (int i = 0; i < componentProps.Count; i++)
            {
                PropertyDescriptor prop = componentProps[i];
                if (!prop.IsReadOnly && ManagedPropertiesService.IsTypeSupported(prop.PropertyType))
                {
                    bool            recommended = ((RecommendedAsConfigurableAttribute)prop.Attributes[typeof(RecommendedAsConfigurableAttribute)]).RecommendedAsConfigurable;
                    PropertyBinding binding     = bindings[component, prop];
                    if (recommended || (binding != null && binding.Bound))
                    {
                        props.Add(new BindingPropertyDescriptor(compSettings, prop));
                    }
                }
            }

            // add the (Advanced...) property
            props.Add(new AdvancedPropertyDescriptor(compSettings));

            PropertyDescriptor[] propsArray = new PropertyDescriptor[props.Count];
            for (int i = 0; i < props.Count; i++)
            {
                propsArray[i] = (PropertyDescriptor)props[i];
            }
            return(new PropertyDescriptorCollection(propsArray));
        }
 /// <include file='doc\SingleBindingDialog.uex' path='docs/doc[@for="SingleBindingDialog.SingleBindingDialog"]/*' />
 /// <devdoc>
 /// Creates a new dialog to let the user edit dynamic property bindings.
 /// The bindings parameter must have all possible bindings in it for the
 /// components and their properties, even if none are bound. For unbound
 /// properties, the key property on the binding should be
 /// initialized to its suggested (default) values.
 /// </devdoc>
 public SingleBindingDialog(PropertyBinding binding)
 {
     this.binding = binding;
     this.InitializeComponent();
     FillUI();
 }
Exemple #9
0
        /// <include file='doc\AdvancedPropertyEditor.uex' path='docs/doc[@for="AdvancedPropertyEditor.EditValue"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {
            ComponentSettings compSettings = ((AdvancedPropertyDescriptor)value).ComponentSettings;
            IComponent        component    = compSettings.Component;

            // make sure it's OK to change
            IComponentChangeService changeService = null;

            if (component.Site != null)
            {
                changeService = (IComponentChangeService)component.Site.GetService(typeof(IComponentChangeService));
            }
            if (changeService != null)
            {
                try {
                    changeService.OnComponentChanging(component, (PropertyDescriptor)value);
                }
                catch (CheckoutException e) {
                    if (e == CheckoutException.Canceled)
                    {
                        return(value);
                    }
                    throw e;
                }
            }

            IWindowsFormsEditorService editorSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));

            Debug.Assert(editorSvc != null, "Couldn't get IWindowsFormsEditorService");
            if (editorSvc != null)
            {
                try {
                    using (AdvancedPropertyDialog dlg = new AdvancedPropertyDialog(component)) {
                        DialogResult result = editorSvc.ShowDialog(dlg);
                        if (result == DialogResult.OK)
                        {
                            bool changeMade = false;
                            PropertyBindingCollection newBindings = dlg.Bindings;
                            ManagedPropertiesService  svc         = (ManagedPropertiesService)context.GetService(typeof(ManagedPropertiesService));
                            Debug.Assert(svc != null, "Couldn't get ManagedPropertiesService");
                            if (svc != null)
                            {
                                for (int i = 0; i < newBindings.Count; i++)
                                {
                                    svc.EnsureKey(newBindings[i]);
                                    PropertyBinding oldBinding = svc.Bindings[component, newBindings[i].Property];
                                    if (oldBinding == null)
                                    {
                                        if (newBindings[i].Bound)
                                        {
                                            changeMade = true;
                                        }
                                    }
                                    else if ((oldBinding.Bound != newBindings[i].Bound) || (oldBinding.Key != newBindings[i].Key))
                                    {
                                        changeMade = true;
                                    }
                                    svc.Bindings[component, newBindings[i].Property] = newBindings[i];
                                }
                                svc.MakeDirty();

                                if (changeMade)
                                {
                                    TypeDescriptor.Refresh(compSettings.Component);
                                    if (changeService != null)
                                    {
                                        changeService.OnComponentChanged(compSettings.Component, null, null, null);
                                    }
                                    try {
                                        svc.WriteConfigFile();
                                    }
                                    catch {
                                    }
                                }

                                // this fools the properties window into thinking we changed the value, so it refreshes
                                // the owner object.
                                object retval = new AdvancedPropertyDescriptor(compSettings);
                                return(retval);
                            }
                        }
                    }
                }
                catch (Exception e) {
                    System.Windows.Forms.MessageBox.Show(e.Message, SR.GetString(SR.ConfigConfiguredProperties));
                }
            }

            return(value);
        }
 /// <include file='doc\PropertyBindingCollection.uex' path='docs/doc[@for="PropertyBindingCollection.Remove"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public void Remove(PropertyBinding binding)
 {
     contents.Remove(binding);
     //hashedContents.Remove(new InstancedPropertyDescriptor(binding.ComponentName, binding.Property));
 }
 /// <include file='doc\PropertyBindingCollection.uex' path='docs/doc[@for="PropertyBindingCollection.Add"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public void Add(PropertyBinding binding)
 {
     contents.Add(binding);
     //hashedContents[new InstancedPropertyDescriptor(binding.ComponentName, binding.Property)] = binding;
 }
        /// <include file='doc\BindingPropertyDescriptor.uex' path='docs/doc[@for="BindingPropertyDescriptor.SetValue"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public override void SetValue(object component, object newBinding)
        {
            // Debug.Assert(compSettings == component, "I don't get it - component is a " + component.GetType().FullName);
            Debug.Assert(newBinding is PropertyBinding || newBinding is string, "I still don't get it " + newBinding.GetType().FullName + " " + newBinding.ToString());

            // make sure it's OK to change property.
            IComponentChangeService svc = null;

            if (compSettings.Component.Site != null)
            {
                svc = (IComponentChangeService)compSettings.Component.Site.GetService(typeof(IComponentChangeService));
            }
            if (svc != null)
            {
                try {
                    svc.OnComponentChanging(compSettings.Component, this);
                }
                catch (CheckoutException e) {
                    if (e == CheckoutException.Canceled)
                    {
                        return;
                    }
                    throw e;
                }
            }

            PropertyBinding binding;

            if (newBinding is PropertyBinding)
            {
                binding = (PropertyBinding)newBinding;
            }
            else
            {
                binding      = new PropertyBinding((PropertyBinding)GetValue(component));
                binding.Host = GetHost();
                if (newBinding == (object)PropertyBinding.None)
                {
                    binding.Bound = false;
                }
                else
                {
                    binding.Bound   = true;
                    binding.Enabled = false;   // this will be set to true in EnsureKey if appropriate
                    binding.Key     = (string)newBinding;
                }
            }

            compSettings.Bindings[compSettings.Component, property] = binding;
            //  if the key doesn't exist, use this property's value to set it.
            compSettings.Service.EnsureKey(binding);
            compSettings.Service.MakeDirty();
            compSettings.Service.WriteConfigFile();

            // now announce that it's changed
            TypeDescriptor.Refresh(compSettings.Component);
            if (svc != null)
            {
                svc.OnComponentChanged(compSettings.Component, null, null, null);
            }

            OnValueChanged(component, EventArgs.Empty);
        }
        /// <include file='doc\BindingPropertyDescriptor.uex' path='docs/doc[@for="BindingPropertyDescriptor.ResetValue"]/*' />
        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public override void ResetValue(object component)
        {
            PropertyBinding binding = (PropertyBinding)GetValue(component);

            binding.Reset();
        }