/// <summary>
 /// Resets the property value on all selected objects.</summary>
 public virtual void ResetValue()
 {
     m_transactionContext.DoTransaction(delegate
     {
         PropertyUtils.ResetProperty(SelectedObjects, m_descriptor);
     },
                                        string.Format("Reset: {0}".Localize(), m_descriptor.DisplayName));
 }
Beispiel #2
0
 /// <summary>
 /// Resets the property value on all selected objects.</summary>
 public virtual void ResetValue()
 {
     m_transactionContext.DoTransaction(delegate
     {
         PropertyUtils.ResetProperty(SelectedObjects, m_descriptor);
     },
                                        "Reset Property".Localize());
 }
        /// <summary>
        /// Returns property descriptors for the object</summary>
        /// <param name="owner">Object with properties</param>
        /// <returns>Array of property descriptors for the object</returns>
        public virtual PropertyDescriptor[] GetPropertyDescriptors(object owner)
        {
            if (m_innerContext != null)
            {
                return(m_innerContext.GetPropertyDescriptors(owner));
            }

            return(PropertyUtils.GetDefaultProperties2(owner));
        }
Beispiel #4
0
        private void OpenDropDownEditor()
        {
            if (m_isEditing)
            {
                return;
            }
            try
            {
                m_isEditing = true;
                object oldValue, value;
                var    oldContext = m_context;

                // Alan Beckus: save references to all the required objects to perform the transaction.
                // Because EditValue(...) enters modal loop using Application.DonEvent()
                // consequently selectedObjects, transaction and event m_context itself can change
                // before returning from EditValue(...).
                // note: previous attempt to solve this issue was to cache selected objects inside
                //       m_context but it failed to solve the issue because the cache was cleared
                //       by PropertyView before it can be used.
                List <object> selection          = new List <object>(m_context.SelectedObjects);
                var           transactionContext = m_context.TransactionContext;
                var           descriptor         = m_context.Descriptor;
                oldValue = m_context.GetValue();

                UITypeEditor editor = WinFormsPropertyUtils.GetUITypeEditor(m_descriptor, this);

                // Bring up the editor which can cause Bind() to be called, so make sure that we use the
                //  correct context and selection after this EditValue call.
                value = editor.EditValue(this, this, oldValue);


                transactionContext.DoTransaction(delegate
                {
                    foreach (object selectedObject in selection)
                    {
                        PropertyUtils.SetProperty(selectedObject, descriptor, value);
                    }
                }, string.Format("Edit: {0}".Localize(), descriptor.DisplayName));


                // notify that we just changed a value
                NotifyPropertyEdit(oldValue, value);

                // Refresh text box, paint rect
                if (oldContext == m_context)
                {
                    SetTextBoxFromProperty();
                    EnableTextBox();
                }

                Invalidate();
            }
            finally
            {
                m_isEditing = false;
            }
        }
 /// <summary>
 /// Sets the property value on all selected objects</summary>
 /// <param name="newValue">New property value</param>
 public virtual void SetValue(object newValue)
 {
     m_transactionContext.DoTransaction(delegate
     {
         foreach (object selectedObject in SelectedObjects)
         {
             PropertyUtils.SetProperty(selectedObject, m_descriptor, newValue);
         }
     },
                                        string.Format("Edit: {0}".Localize(), m_descriptor.DisplayName));
 }
Beispiel #6
0
 /// <summary>
 /// Sets the property value on all selected objects</summary>
 /// <param name="newValue">New property value</param>
 public virtual void SetValue(object newValue)
 {
     m_transactionContext.DoTransaction(delegate
     {
         foreach (object selectedObject in SelectedObjects)
         {
             PropertyUtils.SetProperty(selectedObject, m_descriptor, newValue);
         }
     },
                                        "Edit Property".Localize());
 }
Beispiel #7
0
 private void SetTextBoxFromProperty()
 {
     if (m_context != null && m_context.LastSelectedObject != null)
     {
         string propertyText = PropertyUtils.GetPropertyText(m_context.LastSelectedObject, m_descriptor);
         m_initialText       = propertyText;
         m_textBox.Text      = propertyText;
         m_textBox.Font      = Font;
         m_textBox.ReadOnly  = m_descriptor.IsReadOnly;
         m_textBox.ForeColor = (m_descriptor.IsReadOnly) ? SystemColors.GrayText : ForeColor;
     }
 }
        private static bool[] GetEqualComponents(Array refArray, Array newArray)
        {
            bool[] result = new bool[newArray.Length];
            if (refArray != null)
            {
                for (int i = 0; i < newArray.Length; i++)
                {
                    result[i] = PropertyUtils.AreEqual(newArray.GetValue(i), refArray.GetValue(i));
                }
            }

            return(result);
        }
Beispiel #9
0
        /// <summary>
        /// Draws the property editing representation, in the same way that the control
        /// presents the property in the GUI. Use this method to draw inactive properties
        /// when multitasking a single PropertyEditingControl.</summary>
        /// <param name="descriptor">Property descriptor</param>
        /// <param name="context">Type descriptor context</param>
        /// <param name="bounds">Bounds containing graphics</param>
        /// <param name="font">Font to use for rendering property text</param>
        /// <param name="brush">Brush for rendering property text</param>
        /// <param name="g">Graphics object</param>
        public static void DrawProperty(
            PropertyDescriptor descriptor,
            ITypeDescriptorContext context,
            Rectangle bounds,
            Font font,
            Brush brush,
            Graphics g)
        {
            object owner = context.Instance;

            if (owner == null)
            {
                return;
            }

            UITypeEditor editor = WinFormsPropertyUtils.GetUITypeEditor(descriptor, context);

            if (editor != null)
            {
                if (editor.GetPaintValueSupported(context))
                {
                    object    value     = descriptor.GetValue(owner);
                    Rectangle paintRect = new Rectangle(
                        bounds.Left + 1,
                        bounds.Top + 1,
                        PaintRectWidth,
                        PaintRectHeight);
                    editor.PaintValue(new PaintValueEventArgs(context, value, g, paintRect));
                    bounds.X     += PaintRectTextOffset;
                    bounds.Width -= PaintRectTextOffset;

                    g.DrawRectangle(SystemPens.ControlDark, paintRect);
                }
            }

            string valueString = PropertyUtils.GetPropertyText(owner, descriptor);

            bounds.Height = font.Height;

            if (s_textFormat.CustomFlags == CustomStringFormatFlags.TrimLeftWithEllipses)
            {
                valueString = TrimStringLeftWithEllipses(valueString, bounds, font, g);
            }

            g.DrawString(valueString, font, brush, bounds, s_textFormat.Format);
        }
        /// <summary>
        /// Sets the Array property value on all selected objects</summary>
        /// <param name="refArray">Reference array that the user sees as the old value</param>
        /// <param name="newArray">New array that the user edited</param>
        public void SetValue(Array refArray, Array newArray)
        {
            bool[] equalComponents = GetEqualComponents(refArray, newArray);

            m_transactionContext.DoTransaction(delegate
            {
                foreach (object selectedObject in SelectedObjects)
                {
                    Array oldArray    = (Array)m_descriptor.GetValue(selectedObject);
                    Array mergedArray = GetMergedArray(selectedObject, oldArray, newArray, equalComponents);
                    //if (!PropertyUtils.AreEqual(oldArray, mergedArray)) TODO make command combining more sophisticated
                    {
                        PropertyUtils.SetProperty(selectedObject, m_descriptor, mergedArray);
                    }
                }
            },
                                               string.Format("Edit: {0}".Localize(), m_descriptor.DisplayName));
        }
Beispiel #11
0
        /// <summary>
        /// Sets the property value to the new value</summary>
        /// <param name="owner">Object whose property is set</param>
        /// <param name="descriptor">Property descriptor</param>
        /// <param name="value">New property value</param>
        public static void SetProperty(object owner, PropertyDescriptor descriptor, object value)
        {
            try
            {
                TypeConverter converter = descriptor.Converter;
                if (converter != null &&
                    value != null &&
                    converter.CanConvertFrom(value.GetType()))
                {
                    value = converter.ConvertFrom(value);
                }

                bool   notifyChange = false;
                object oldValue     = null;
                EventHandler <PropertyEditedEventArgs> handler = PropertyEdited;
                if (handler != null)
                {
                    oldValue     = descriptor.GetValue(owner);
                    notifyChange = !PropertyUtils.AreEqual(oldValue, value);
                }
                descriptor.SetValue(owner, value);
                if (notifyChange)
                {
                    PropertyEditedEventArgs eventArgs = new PropertyEditedEventArgs(owner, descriptor, oldValue, value);
                    handler(null, eventArgs);
                }
            }
            catch (InvalidTransactionException)
            {
                // The transaction needs to be cancelled.
                throw;
            }
            catch (Exception ex)
            {
                PropertyErrorEventArgs eventArgs = new PropertyErrorEventArgs(owner, descriptor, ex);

                PropertyError.Raise(null, eventArgs);

                if (!eventArgs.Cancel)
                {
                    Outputs.WriteLine(OutputMessageType.Error, ex.Message);
                }
            }
        }
 /// <summary>
 /// Returns whether or not the given values are equal</summary>
 /// <param name="value1">First value</param>
 /// <param name="value2">Second value</param>
 /// <returns>True iff the given values are equal</returns>
 /// <remarks>Default is to do limited deep equality testing for array types, and
 /// allow small errors with floating point types. Override to customize this behavior.</remarks>
 public virtual bool AreEqual(object value1, object value2)
 {
     return(PropertyUtils.AreEqual(value1, value2));
 }
        /// <summary>
        /// Gets property text for this property, possibly using a TypeConverter</summary>
        /// <returns>Property text for this property</returns>
        public string GetPropertyText()
        {
            string text = PropertyUtils.GetPropertyText(LastSelectedObject, m_descriptor);

            return(text);
        }
 /// <summary>
 /// Gets the property descriptors for the given item in the collection</summary>
 /// <param name="item">The item in the collection</param>
 /// <returns>Property descriptor array for the given item in the collection</returns>
 protected virtual PropertyDescriptor[] GetDescriptors(object item)
 {
     return(PropertyUtils.GetDefaultProperties2(item));
 }