예제 #1
0
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            PropInPlaceRadioButton radioButton;

            if (mInPlaceCtrl == null)
            {
                radioButton         = new PropInPlaceRadioButton();
                radioButton.Visible = false;
                radioButton.Parent  = mParentWnd;
                mInPlaceCtrl        = radioButton;
            }
            else
            {
                radioButton = (PropInPlaceRadioButton)mInPlaceCtrl;
            }

            NotifyInPlaceControlCreated(propEnum);

//            radioButton.Text = propEnum.Property.Value.DisplayString;
            radioButton.OwnerPropertyEnumerator = propEnum;
            radioButton.Font = propEnum.Property.Value.Font;

            MoveControl(valueRect, propEnum);

            return(base.ShowControl(valueRect, propEnum));
        }
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
//            if (propEnum.Property.Value.IsReadOnly(propEnum))
  //              return null;

            PropInPlaceUITypeEditor inPlaceCtrl;

            if (mInPlaceCtrl == null)
            {
                inPlaceCtrl = new PropInPlaceUITypeEditor(_editor, true);
                inPlaceCtrl.Visible = false;
                inPlaceCtrl.Parent = mParentWnd;
                mInPlaceCtrl = inPlaceCtrl;
            }
            else
                inPlaceCtrl = (PropInPlaceUITypeEditor)mInPlaceCtrl;

            NotifyInPlaceControlCreated(propEnum);
/*
            if (propEnum.Property.Value.HasMultipleValues)
                inPlaceCtrl.Text = "";
            else
                inPlaceCtrl.Text = propEnum.Property.Value.DisplayString;
*/
            inPlaceCtrl.OwnerPropertyEnumerator = propEnum;
            inPlaceCtrl.Font = propEnum.Property.Value.Font;

            MoveControl(valueRect, propEnum);

            return base.ShowControl(valueRect, propEnum);
        }
예제 #3
0
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if (DontShowInPlaceCtrl(propEnum))
            {
                return(null);
            }

            PropInPlaceList list;

            if (mInPlaceCtrl == null)
            {
                list         = new PropInPlaceList(_editable);
                list.Visible = false;
                list.Parent  = mParentWnd;
                mInPlaceCtrl = list;
            }
            else
            {
                list = (PropInPlaceList)mInPlaceCtrl;
            }

            NotifyInPlaceControlCreated(propEnum);

//            list.Text = propEnum.Property.Value.DisplayString;
            list.OwnerPropertyEnumerator = propEnum;
            list.Font = propEnum.Property.Value.Font;

            MoveControl(valueRect, propEnum);

            return(base.ShowControl(valueRect, propEnum));
        }
예제 #4
0
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if ((propEnum.Property.Value.IsReadOnly(propEnum)) && !_editable)
            {
                return(null);
            }

            PropInPlaceButton button;

            if (mInPlaceCtrl == null)
            {
                button         = new PropInPlaceButton(_editable);
                button.Visible = false;
                button.Parent  = mParentWnd;
                mInPlaceCtrl   = button;
            }
            else
            {
                button = (PropInPlaceButton)mInPlaceCtrl;
            }

            NotifyInPlaceControlCreated(propEnum);

//            button.Text = propEnum.Property.Value.DisplayString;

            button.OwnerPropertyEnumerator = propEnum;

            button.Font = propEnum.Property.Value.Font;

            MoveControl(valueRect, propEnum);

            return(base.ShowControl(valueRect, propEnum));
        }
예제 #5
0
        public override void DrawCategoryLabelBackground(Graphics graphics, Rectangle rect, PropertyEnumerator enumSelf)
        {
            Rectangle fillRect = Rectangle.Intersect(rect, Rectangle.Round(graphics.ClipBounds));
            if (fillRect.IsEmpty)
                return;

            Rectangle labelRect = enumSelf.Property.GetLabelColumnRect(rect, enumSelf);
            rect.Y++;
            rect.Height -= 3;

            fillRect = rect;
            int margin = enumSelf.Property.ParentGrid.GlobalTextMargin;
            fillRect.X = labelRect.Left + margin / 2;
            fillRect.Width = rect.Right - fillRect.Left;

            Brush brush;
            if (enumSelf.Property.Selected)	// if selected
                brush = new SolidBrush(Grid.GridContainsFocus ? Grid.SelectedBackColor : Grid.SelectedNotFocusedBackColor);
            else
                brush = new LinearGradientBrush(fillRect, _categoryBkgColor1, _categoryBkgColor2, 0.0f);

            graphics.FillRectangle(brush, fillRect);

            brush.Dispose();
        }
예제 #6
0
        public override void DrawCategoryLabelBackground(Graphics graphics, Rectangle rect, PropertyEnumerator enumSelf)
        {
            Rectangle fillRect = Rectangle.Intersect(rect, Rectangle.Round(graphics.ClipBounds));
            if (fillRect.IsEmpty)
                return;

            Brush brush;

            if (enumSelf.Property.Selected) 	// if selected
            {
                Color bkgColor;

                if (Grid.GridContainsFocus)
                    bkgColor = Grid.SelectedBackColor;
                else
                {
                    // If the control has not the focus, the background is light
                    bkgColor = Grid.SelectedNotFocusedBackColor;
                }

                brush = new SolidBrush(bkgColor);
            }
            else
                brush = new SolidBrush(Grid.GridBackColor);

            graphics.FillRectangle(brush, rect);
        }
예제 #7
0
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
//            if (propEnum.Property.Value.IsReadOnly(propEnum))
//              return null;

            PropInPlaceUITypeEditor inPlaceCtrl;

            if (mInPlaceCtrl == null)
            {
                inPlaceCtrl         = new PropInPlaceUITypeEditor(_editor, true);
                inPlaceCtrl.Visible = false;
                inPlaceCtrl.Parent  = mParentWnd;
                mInPlaceCtrl        = inPlaceCtrl;
            }
            else
            {
                inPlaceCtrl = (PropInPlaceUITypeEditor)mInPlaceCtrl;
            }

            NotifyInPlaceControlCreated(propEnum);

/*
 *          if (propEnum.Property.Value.HasMultipleValues)
 *              inPlaceCtrl.Text = "";
 *          else
 *              inPlaceCtrl.Text = propEnum.Property.Value.DisplayString;
 */
            inPlaceCtrl.OwnerPropertyEnumerator = propEnum;
            inPlaceCtrl.Font = propEnum.Property.Value.Font;

            MoveControl(valueRect, propEnum);

            return(base.ShowControl(valueRect, propEnum));
        }
 public ValueValidationEventArgs(PropertyEnumerator propEnum, PropertyEnumerator invalidPropEnum, object value, PropertyValue.ValueValidationResult result)
     : base(propEnum)
 {
     _valueValidationResult = result;
     _valueToValidate = value;
     _invalidPropEnum = invalidPropEnum;
 }
예제 #9
0
        public override void OnDraw(Graphics graphics, Rectangle valueRect, Color textColor, PropertyEnumerator propEnum, string drawAnotherString)
        {
            valueRect.Height++;

            Rectangle colorRect = GetColorRect(valueRect);

            // Draw the color box
            Color color;
            try
            {
                color = (Color)Value.GetActualValue(drawAnotherString);
            }
            catch (Exception)
            {
                color = (Color)Value.GetValue();
            }
            Brush brush = new SolidBrush(color);
            graphics.FillRectangle(brush, colorRect);

            if (propEnum.Property.Value.HasMultipleValues)
                graphics.DrawLine(SystemPens.GrayText, colorRect.Left, colorRect.Bottom, colorRect.Right, colorRect.Top);

            // Draw a black frame around
            Pen pen = new Pen(Color.Black);
            graphics.DrawRectangle(pen, colorRect);
            pen.Dispose();

            Rectangle strRect = GetDisplayStringRect(graphics, valueRect, Point.Empty /* not used */);
            strRect.Width = valueRect.Right - strRect.Left;

            Win32Calls.DrawText(graphics, (drawAnotherString == null ? DisplayString : drawAnotherString),
                ref strRect, Value.Font, textColor,
                Win32Calls.DT_VCENTER | Win32Calls.DT_SINGLELINE | Win32Calls.DT_END_ELLIPSIS | Win32Calls.DT_NOPREFIX);
        }
예제 #10
0
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            PropInPlaceUnit unit;

            if (mInPlaceCtrl == null)
            {
                unit         = new PropInPlaceUnit();
                unit.Visible = false;
                unit.Parent  = mParentWnd;
                mInPlaceCtrl = unit;
            }
            else
            {
                unit = (PropInPlaceUnit)mInPlaceCtrl;
            }

            NotifyInPlaceControlCreated(propEnum);

//            unit.Text = propEnum.Property.Value.DisplayString;
            unit.OwnerPropertyEnumerator = propEnum;
            unit.Font = propEnum.Property.Value.Font;

            MoveControl(valueRect, propEnum);

            return(base.ShowControl(valueRect, propEnum));
        }
예제 #11
0
        public override bool IsReadOnly(PropertyEnumerator selfEnum)
        {
            if (!Grid.Grid.Enabled && (Grid.DisableMode == PropertyGrid.DisableModes.Simple))
            {
                return(true);
            }

            if ((selfEnum.Parent.Property != null) && (selfEnum.Parent.Property.Value != null))
            {
                if (!selfEnum.Parent.Property.Value.NoLinkWithChildren &&
                    (selfEnum.Parent.Property.Value.IsReadOnly(selfEnum.Parent)))
                {
                    return(true);
                }
            }

            // Check if a UITypeEditor has been found. Even if the property is marked Readonly (has only a get
            // accessor for example), the presence of an editor makes it editable (this is the case for collections
            // for example in the .net framework)
            ReadOnlyAttribute manualReadOnlyAttr = (ReadOnlyAttribute)base.GetAttribute(typeof(ReadOnlyAttribute));

            if ((mFeel is PropertyUITypeEditorFeel) && ((manualReadOnlyAttr == null) || !manualReadOnlyAttr.IsReadOnly))
            {
                return(false);
            }

            ReadOnlyAttribute attr = (ReadOnlyAttribute)GetAttribute(typeof(ReadOnlyAttribute));

            return((attr != null) && attr.IsReadOnly);
        }
예제 #12
0
        public override void MoveControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
	        if (mInPlaceCtrl == null)
		        return;

            mInPlaceCtrl.BackColor = propEnum.Property.Value.BackColor;

            // Find where the string is actually displayed (a look instance could place it anywhere)
            Graphics graphics = mParentWnd.CreateGraphics();
	        Rectangle strRect = propEnum.Property.Value.GetStringValueRect(graphics, valueRect, Point.Empty /* not used */);
            strRect.X -= (propEnum.Property.Value.EditboxLeftMargin == -1 ?
                propEnum.Property.ParentGrid.GlobalTextMargin :
                propEnum.Property.Value.EditboxLeftMargin);
            strRect.Width = valueRect.Right - strRect.Left;

            // Calculate the height of the editbox, based on the font height

            Rectangle editRect = strRect;
            editRect.Inflate(0,-1);

            Win32Calls.TEXTMETRIC tm = new Win32Calls.TEXTMETRIC();
            Win32Calls.GetTextMetrics(graphics, mInPlaceCtrl.Font, ref tm);

            graphics.Dispose();

            int extraHeight = editRect.Height - tm.tmHeight;
            editRect.Y += extraHeight / 2;
            editRect.Height -= extraHeight;

            if (mInPlaceCtrl.Bounds != editRect)
                mInPlaceCtrl.Bounds = editRect;
        }
예제 #13
0
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if ((propEnum.Property.Value.IsReadOnly(propEnum)) && !_editable)
            {
                return(null);
            }

            PropInPlaceTrackbar trackbar;

            if (mInPlaceCtrl == null)
            {
                trackbar         = new PropInPlaceTrackbar(_editable);
                trackbar.Visible = false;
                trackbar.Parent  = mParentWnd;
                mInPlaceCtrl     = trackbar;
            }
            else
            {
                trackbar = (PropInPlaceTrackbar)mInPlaceCtrl;
            }

            NotifyInPlaceControlCreated(propEnum);

            trackbar.OwnerPropertyEnumerator = propEnum;

            trackbar.Font = propEnum.Property.Value.Font;

            MoveControl(valueRect, propEnum);

            return(base.ShowControl(valueRect, propEnum));
        }
예제 #14
0
        public override Rectangle GetManuallyDisableRect(Rectangle itemRect, PropertyEnumerator enumSelf)
        {
            if (CanBeDisabledManually == false)
            {
                return(Rectangle.Empty);
            }

            Rectangle frameRect = itemRect;
            Rectangle signRect  = GetSignRect(itemRect, enumSelf);

            if (signRect != Rectangle.Empty)
            {
                frameRect.X = ParentGrid.GlobalTextMargin + signRect.Right;
            }
            else
            {
                frameRect.X = ParentGrid.GlobalTextMargin + ParentGrid.LeftColumnWidth + 1 +
                              (enumSelf.Depth - 1) * (ParentGrid.GlobalTextMargin + TreeGlyphWidth);
            }

            // Size it based on the row height
            frameRect.Y     += 2;
            frameRect.Height = ParentGrid.BasicPropertyHeight - 4;
            frameRect.Width  = frameRect.Height;

            return(frameRect);
        }
예제 #15
0
        public override Rectangle GetLabelTextRect(Rectangle itemRect, PropertyEnumerator enumSelf)
        {
            Font     underlinedFont = new Font(Font, FontStyle.Underline);
            Graphics graphics       = ParentGrid.CreateGraphics();

            Size textSize = Win32Calls.GetTextExtent(graphics, DisplayName, underlinedFont);

            Rectangle labelColumnRect = GetLabelColumnRect(itemRect, enumSelf);

            labelColumnRect.Inflate(-ParentGrid.GlobalTextMargin, 0);
            Rectangle labelRect = labelColumnRect;

            if (textSize.Width <= labelColumnRect.Width)
            {
                labelRect.X     = labelColumnRect.Right - textSize.Width;
                labelRect.Width = textSize.Width;
            }
            else
            {
                labelRect.Width = labelColumnRect.Right - labelRect.Left;
            }

            graphics.Dispose();
            underlinedFont.Dispose();

            return(labelRect);
        }
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if (DontShowInPlaceCtrl(propEnum))
                return null;

            PropInPlaceList list;

            if (mInPlaceCtrl == null)
            {
                list = new PropInPlaceList(_editable);
                list.Visible = false;
                list.Parent = mParentWnd;
                mInPlaceCtrl = list;
            }
            else
                list = (PropInPlaceList)mInPlaceCtrl;

            NotifyInPlaceControlCreated(propEnum);

//            list.Text = propEnum.Property.Value.DisplayString;
            list.OwnerPropertyEnumerator = propEnum;
            list.Font = propEnum.Property.Value.Font;

            MoveControl(valueRect, propEnum);

            return base.ShowControl(valueRect, propEnum);
        }
예제 #17
0
        /// <summary>
        /// Removes a property from the tree.
        /// </summary>
        /// <param name="propEnum">An enumerator pointing to the property to remove from the tree.</param>
        /// <returns>A deep enumerator on the property that would be naturally selected if the deleted
        /// item was selected.</returns>
        public PropertyEnumerator Delete(PropertyEnumerator propEnum)
        {
            // Store the previous property (deep)
            PropertyDeepEnumerator dEnumerator = new PropertyDeepEnumerator(propEnum.Node);

            dEnumerator.MovePrev();

            // Remove the property
            propEnum.Node.Owner.Remove(propEnum.Node);

            // Determine the next property of the property that was deleted
            if (dEnumerator.MoveNext() == dEnumerator.RightBound)
            {
                dEnumerator.MovePrev();
            }
            if (dEnumerator == dEnumerator.LeftBound)
            {
                dEnumerator = dEnumerator.RightBound.GetDeepEnumerator();
            }

            // Since the enumerator passed in argument now points to an invalid property,
            // we make it point to the next property (the previous one if no next exists)
            propEnum.Node = dEnumerator.Node;

            return(dEnumerator);
        }
예제 #18
0
        public override System.Windows.Forms.Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if ((propEnum.Property.Value.IsReadOnly(propEnum)) && !_editable)
                return null;

            PropInPlaceUpDown upDown;

            if (mInPlaceCtrl == null)
            {
                upDown = new PropInPlaceUpDown(_editable);
                upDown.Visible = false;
                upDown.Parent = mParentWnd;
                mInPlaceCtrl = upDown;
            }
            else
                upDown = (PropInPlaceUpDown)mInPlaceCtrl;

            NotifyInPlaceControlCreated(propEnum);

//            upDown.Text = propEnum.Property.Value.DisplayString;
            upDown.OwnerPropertyEnumerator = propEnum;
            upDown.Font = propEnum.Property.Value.Font;

            MoveControl(valueRect, propEnum);

            return base.ShowControl(valueRect, propEnum);
        }
예제 #19
0
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if ((propEnum.Property.Value.IsReadOnly(propEnum)) && !_editable)
                return null;

            PropInPlaceButton button;

            if (mInPlaceCtrl == null)
            {
                button = new PropInPlaceButton(_editable);
                button.Visible = false;
                button.Parent = mParentWnd;
                mInPlaceCtrl = button;
            }
            else
                button = (PropInPlaceButton)mInPlaceCtrl;

            NotifyInPlaceControlCreated(propEnum);

//            button.Text = propEnum.Property.Value.DisplayString;

            button.OwnerPropertyEnumerator = propEnum;

            button.Font = propEnum.Property.Value.Font;

            MoveControl(valueRect, propEnum);

            return base.ShowControl(valueRect, propEnum);
        }
예제 #20
0
        public override Rectangle GetImageRect(Rectangle itemRect, PropertyEnumerator enumSelf)
        {
            if (ImageIndex == -1)
            {
                return(Rectangle.Empty);
            }

            Rectangle imgRect = itemRect;

            imgRect.X = ParentGrid.LeftColumnWidth + 1 + ParentGrid.GlobalTextMargin;

            try
            {
                Image img = ParentGrid.ImageList.Images[ImageIndex];
                imgRect.Width  = img.Width;
                imgRect.Height = img.Height;
            }
            catch (Exception)
            {
                return(Rectangle.Empty);
            }

            imgRect.Y = itemRect.Top + itemRect.Height / 2 - 8;

            return(imgRect);
        }
예제 #21
0
        public virtual System.Windows.Forms.Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if (mInPlaceCtrl != null)
            {
                mInPlaceCtrl.Visible   = true;
                mInPlaceCtrl.BackColor = propEnum.Property.Value.BackColor;

                if (propEnum.Property.Value.ReadOnly)
                {
                    if ((mPropCtrl.Enabled == false) &&
                        (mPropCtrl.DisableMode != PropertyGrid.DisableModes.None) &&
                        mPropCtrl.DisableModeGrayedOut)
                    {
                        mInPlaceCtrl.ForeColor = mPropCtrl.DisabledForeColor;
                    }
                    else
                    {
                        mInPlaceCtrl.ForeColor = propEnum.Property.Value.ReadOnlyForeColor;
                    }
                }
                else
                {
                    mInPlaceCtrl.ForeColor = propEnum.Property.Value.ForeColor;
                }
            }

            mPropCtrl.OnInPlaceCtrlVisible(new InPlaceCtrlVisibleEventArgs(propEnum, mInPlaceCtrl));

            return(mInPlaceCtrl);
        }
예제 #22
0
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if ((propEnum.Property.Value.IsReadOnly(propEnum)) && !_editable)
            {
                return(null);
            }

            PropInPlaceColorChooser colorChooser;

            if (mInPlaceCtrl == null)
            {
                colorChooser         = new PropInPlaceColorChooser(_editable);
                colorChooser.Visible = false;
                colorChooser.Parent  = mParentWnd;
                mInPlaceCtrl         = colorChooser;
            }
            else
            {
                colorChooser = (PropInPlaceColorChooser)mInPlaceCtrl;
            }

            colorChooser.Font = propEnum.Property.Value.Font;
            colorChooser.Text = propEnum.Property.Value.DisplayString;

            MoveControl(valueRect, propEnum, false);

            colorChooser.OwnerPropertyEnumerator = propEnum;

            return(base.ShowControl(valueRect, propEnum));
        }
        public override System.Windows.Forms.Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            PropInPlaceTextbox edit = null;

            if (mInPlaceCtrl == null)
            {
                edit = new PropInPlaceTextbox(false);
                edit.Visible = false;
                edit.Parent = mParentWnd;
                edit.Multiline = true;
                mInPlaceCtrl = edit;
            }
            else
                edit = (PropInPlaceTextbox)mInPlaceCtrl;

            NotifyInPlaceControlCreated(propEnum);

            edit.OwnerPropertyEnumerator = propEnum;
            edit.Font = propEnum.Property.Value.Font;

            MoveControl(valueRect, propEnum);

            if (edit.Focused == false)		// are we already being editing ? If yes, don't touch the edit content
            {
                if (edit.Text != propEnum.Property.Value.DisplayString)
                    edit.Text = propEnum.Property.Value.DisplayString;
            }

            return base.ShowControl(valueRect, propEnum);
        }
예제 #24
0
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if ((propEnum.Property.Value.IsReadOnly(propEnum)) && !_editable)
                return null;

            PropInPlaceColorChooser colorChooser;

            if (mInPlaceCtrl == null)
            {
                colorChooser = new PropInPlaceColorChooser(_editable);
                colorChooser.Visible = false;
                colorChooser.Parent = mParentWnd;
                mInPlaceCtrl = colorChooser;
            }
            else
                colorChooser = (PropInPlaceColorChooser)mInPlaceCtrl;

            colorChooser.Font = propEnum.Property.Value.Font;
            colorChooser.Text = propEnum.Property.Value.DisplayString;

            MoveControl(valueRect, propEnum, false);

            colorChooser.OwnerPropertyEnumerator = propEnum;

            return base.ShowControl(valueRect, propEnum);
        }
예제 #25
0
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if ((propEnum.Property.Value.IsReadOnly(propEnum)) && !_editable)
                return null;

            PropInPlaceTrackbar trackbar;

            if (mInPlaceCtrl == null)
            {
                trackbar = new PropInPlaceTrackbar(_editable);
                trackbar.Visible = false;
                trackbar.Parent = mParentWnd;
                mInPlaceCtrl = trackbar;
            }
            else
                trackbar = (PropInPlaceTrackbar)mInPlaceCtrl;

            NotifyInPlaceControlCreated(propEnum);

            trackbar.OwnerPropertyEnumerator = propEnum;

            trackbar.Font = propEnum.Property.Value.Font;

            MoveControl(valueRect, propEnum);

            return base.ShowControl(valueRect, propEnum);
        }
예제 #26
0
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            PropInPlaceCheckbox checkboxes;

            if (mInPlaceCtrl == null)
            {
                checkboxes         = new PropInPlaceCheckbox();
                checkboxes.Visible = false;
                checkboxes.Parent  = mParentWnd;
                mInPlaceCtrl       = checkboxes;
            }
            else
            {
                checkboxes = (PropInPlaceCheckbox)mInPlaceCtrl;
            }

            NotifyInPlaceControlCreated(propEnum);

//            checkboxes.Text = propEnum.Property.Value.DisplayString;
            checkboxes.OwnerPropertyEnumerator = propEnum;
            checkboxes.Font = propEnum.Property.Value.Font;

            MoveControl(valueRect, propEnum);

            return(base.ShowControl(valueRect, propEnum));
        }
예제 #27
0
 public ValueValidationEventArgs(PropertyEnumerator propEnum, PropertyEnumerator invalidPropEnum, object value, PropertyValue.ValueValidationResult result)
     : base(propEnum)
 {
     _valueValidationResult = result;
     _valueToValidate       = value;
     _invalidPropEnum       = invalidPropEnum;
 }
예제 #28
0
        protected override bool SetValueInternal(object value, ValueUpdateSource updateSource)
        {
            bool result = false;

#if _DOTNET2
            NullableConverter nc = TypeConverter as NullableConverter;
            if ((value == null) || ((value != null) && UnderlyingType.IsInstanceOfType(value)) ||
                ((nc != null) && ((value == null) || nc.UnderlyingType.IsInstanceOfType(value))))
#else
            if ((value != null) && UnderlyingType.IsInstanceOfType(value))
#endif
            {
                UnderlyingValue = value;
                result          = true;
            }

            if (updateSource != ValueUpdateSource.FromChild)
            {
                if ((mOwnerEnumerator != null) &&   // mOwnerEnumerator could be null for the boolean of Property._enabledVariable
                    !mOwnerEnumerator.Property.Value.NoLinkWithChildren)
                {
                    PropertyTypeDescriptorContext context = GetTypeDescriptorContext(OwnerEnumerator);
                    if (TypeConverter.GetPropertiesSupported(context) == false)
                    {
                        PropertyEnumerator childEnum = mOwnerEnumerator.Children;
                        if (childEnum.Count > 0)
                        {
                            string masterStr = mOwnerEnumerator.Property.Value.GetStringValue();

                            char separator = mOwnerEnumerator.Property.Value.GroupedValueSeparator;
                            while (childEnum != childEnum.RightBound)
                            {
                                masterStr.TrimStart(null);

                                int count = masterStr.IndexOf(separator);

                                if (count != -1)
                                {
                                    childEnum.Property.Value.SetValue(masterStr.Substring(0, count));
                                    if (count + 2 < masterStr.Length)
                                    {
                                        masterStr = masterStr.Substring(count + 2); // advance after the separator and the leading space
                                    }
                                }
                                else
                                {
                                    childEnum.Property.Value.SetValue(masterStr);
                                    break;
                                }

                                childEnum.MoveNext();
                            }
                        }
                    }
                }
            }

            return(result);
        }
예제 #29
0
 public void UpdateInPlaceControlFromValue(PropertyEnumerator propEnum)
 {
     if (mInPlaceCtrl != null)
     {
         (mInPlaceCtrl as IInPlaceControl).OwnerPropertyEnumerator = propEnum;
         mInPlaceCtrl.Refresh();
     }
 }
예제 #30
0
 public PropertyTypeDescriptorContext(PropertyDescriptor descriptor, object instance,
                                      PropertyEnumerator propEnum, PropertyGrid propGrid)
 {
     _descriptor     = descriptor;
     _targetInstance = instance;
     _propEnum       = propEnum;
     _propertyGrid   = propGrid;
 }
예제 #31
0
        public override Rectangle GetLabelColumnRect(Rectangle itemRect, PropertyEnumerator enumerator)
        {
            Rectangle labelRect = itemRect;
            labelRect.X = ParentGrid.LeftColumnWidth + 1;
            labelRect.Width = itemRect.Right - labelRect.Left;

            return labelRect;
        }
 public PropertyTypeDescriptorContext(PropertyDescriptor descriptor, object instance,
     PropertyEnumerator propEnum, PropertyGrid propGrid)
 {
     _descriptor = descriptor;
     _targetInstance = instance;
     _propEnum = propEnum;
     _propertyGrid = propGrid;
 }
예제 #33
0
        public override void MoveControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if (mInPlaceCtrl == null)
            {
                return;
            }

            if (mInPlaceCtrl is PropInPlaceDateTime)
            {
                valueRect.Height--;

                Win32Calls.RECT rect = new Win32Calls.RECT();
                Win32Calls.GetWindowRect(mInPlaceCtrl.Handle, ref rect);
                Rectangle bounds = Rectangle.FromLTRB(rect.Left, rect.Top, rect.Right, rect.Bottom);
                bounds = mInPlaceCtrl.Parent.RectangleToClient(bounds);

                if (bounds != valueRect)
                {
                    mInPlaceCtrl.Invalidate();

                    // Bounds doesn't work because of DateTimePicker.PreferredHeight
                    Win32Calls.SetWindowPos(mInPlaceCtrl.Handle, IntPtr.Zero, valueRect.Left, valueRect.Top,
                                            valueRect.Width, valueRect.Height, Win32Calls.SWP_NOZORDER | Win32Calls.SWP_NOACTIVATE |
                                            Win32Calls.SWP_NOREDRAW);

                    // Causes WM_NCPAINT
                    Win32Calls.RedrawWindow(mInPlaceCtrl.Handle, IntPtr.Zero, IntPtr.Zero, 0x0561);
                }
            }
            else
            {
                // Find where the string is actually displayed (a look instance could place it anywhere)
                Graphics  graphics = mParentWnd.CreateGraphics();
                Rectangle strRect  = propEnum.Property.Value.GetStringValueRect(graphics, valueRect, Point.Empty /* not used */);
                strRect.X -= (propEnum.Property.Value.EditboxLeftMargin == -1 ? propEnum.Property.ParentGrid.GlobalTextMargin :
                              propEnum.Property.Value.EditboxLeftMargin);
                strRect.Width = valueRect.Right - strRect.Left;

                // Calculate the height of the editbox, based on the font height

                Rectangle editRect = strRect;
                editRect.Inflate(0, -1);

                Win32Calls.TEXTMETRIC tm = new Win32Calls.TEXTMETRIC();
                Win32Calls.GetTextMetrics(graphics, mInPlaceCtrl.Font, ref tm);

                graphics.Dispose();

                int extraHeight = editRect.Height - tm.tmHeight;
                editRect.Y      += extraHeight / 2;
                editRect.Height -= extraHeight;

                if (mInPlaceCtrl.Bounds != editRect)
                {
                    mInPlaceCtrl.Bounds = editRect;
                }
            }
        }
예제 #34
0
        public virtual Rectangle GetLabelColumnRect(Rectangle itemRect, PropertyEnumerator enumerator)
        {
            Rectangle labelRect = itemRect;

            labelRect.X     = ParentGrid.LeftColumnWidth + 1;
            labelRect.Width = ParentGrid.LabelColumnWidth;

            return(labelRect);
        }
예제 #35
0
        protected internal override bool ValidateSelfValueFromModifiedChild(PropertyEnumerator modifiedChildEnum, object value)
        {
            if (Validator != null)
            {
                if (modifiedChildEnum.Property.Value is PropertyValueSimulated)
                {
                    try
                    {
                        PropertyTypeDescriptorContext context    = GetTypeDescriptorContext(modifiedChildEnum);
                        PropertyDescriptorCollection  collection = TypeConverter.GetProperties(context, GetValue());
                        PropertyValue childValue = modifiedChildEnum.Property.Value;

                        if (collection != null)
                        {
                            IDictionary dictionary = new Hashtable(collection.Count);
                            foreach (PropertyDescriptor propertyDescriptor in collection)
                            {
                                if (modifiedChildEnum.Property.Name.Equals(propertyDescriptor.Name))
                                {
                                    if (value is string)
                                    {
                                        dictionary[propertyDescriptor.Name] = childValue.TypeConverter.ConvertFromString(
                                            context, childValue.CultureInfo, childValue.GetActualString(value as string));
                                    }
                                    else
                                    {
                                        dictionary[propertyDescriptor.Name] = value;
                                    }
                                }
                                else
                                {
                                    dictionary[propertyDescriptor.Name] = propertyDescriptor.GetValue(childValue.TargetInstance);
                                }
                            }

                            // Create the parent value from all the sibling values
                            object newParentValue = TypeConverter.CreateInstance(context, dictionary);

                            // Validate the parent value
                            PropertyEnumerator invalidPropEnum;
                            if (ValidateValue(newParentValue, out invalidPropEnum))
                            {
                                return(true);
                            }
                        }
                    }
                    catch (Exception)
                    {
                        return(false);
                    }

                    return(true);
                }
            }

            return(true);
        }
예제 #36
0
        public override Rectangle GetLabelColumnRect(Rectangle itemRect, PropertyEnumerator enumerator)
        {
            Rectangle labelRect = itemRect;

            labelRect.X     = ParentGrid.LeftColumnWidth + 1;
            labelRect.Width = itemRect.Right - labelRect.Left;

            return(labelRect);
        }
예제 #37
0
        public override void DrawLeftColumnBackground(Graphics graphics, Rectangle rect, PropertyEnumerator propEnum)
        {
            Rectangle fillRect = Rectangle.Intersect(rect, Rectangle.Round(graphics.ClipBounds));
            if (fillRect.IsEmpty)
                return;

            using(SolidBrush brush = new SolidBrush(Grid.GridColor))
                graphics.FillRectangle(brush, fillRect);
        }
예제 #38
0
        public override bool ValidateValue(object value, out PropertyEnumerator invalidPropertyEnum)
        {
            invalidPropertyEnum = Grid.RightBound;

            // Validate the underlying value
            if (Validator != null)
            {
                if (Validator.Check(value, false) == false)
                {
                    invalidPropertyEnum = mOwnerEnumerator;
                    return(false);
                }
            }

            // Validate children if any
            if (mOwnerEnumerator != null)
            {
                PropertyEnumerator childEnum = mOwnerEnumerator.Children;
                while (childEnum != childEnum.RightBound)
                {
                    if (childEnum.Property.Value != null)
                    {
                        PropertyValidatorBase validator = childEnum.Property.Value.Validator;
                        if (validator != null)
                        {
                            object childValue = childEnum.Property.Value.PropertyDescriptor.GetValue(value);
                            if (validator.Check(childValue, false) == false)
                            {
                                invalidPropertyEnum = childEnum;
                                return(false);
                            }
                        }
                    }

                    childEnum.MoveNext();
                }
            }

            // Validate parent if any
            if (mOwnerEnumerator != null)
            {
                PropertyEnumerator parentEnum = mOwnerEnumerator.Parent;
                if ((parentEnum.Property != null) && (parentEnum.Property.Value != null))
                {
                    bool valid = parentEnum.Property.Value.ValidateSelfValueFromModifiedChild(mOwnerEnumerator, value);
                    if (!valid)
                    {
                        invalidPropertyEnum = parentEnum;
                    }

                    return(valid);
                }
            }

            return(true);
        }
예제 #39
0
        public virtual void DrawPropertyValueBackground(Graphics graphics, Rectangle rect, PropertyEnumerator enumerator)
        {
            Rectangle fillRect = Rectangle.Intersect(rect, Rectangle.Round(graphics.ClipBounds));
            if (fillRect.IsEmpty)
                return;

            Brush brush = new SolidBrush(enumerator.Property.Value.BackColor);
            graphics.FillRectangle(brush, fillRect);
            brush.Dispose();
        }
예제 #40
0
        public override bool IsReadOnly(PropertyEnumerator selfEnum)
        {
            if (!Grid.Grid.Enabled && (Grid.DisableMode == PropertyGrid.DisableModes.Simple))
                return true;

            if (ParentValue.IsReadOnly(selfEnum.Parent))
                return true;

            return false;
        }
예제 #41
0
        public override bool IsReadOnly(PropertyEnumerator selfEnum)
        {
            if (!Grid.Grid.Enabled && ((Grid.DisableMode & PropertyGrid.DisableModes.Simple) != 0))
            {
                return(true);
            }

            ReadOnlyAttribute attr = (ReadOnlyAttribute)GetAttribute(typeof(ReadOnlyAttribute));

            return((attr != null) && attr.IsReadOnly);
        }
예제 #42
0
        public override void MoveControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if (mInPlaceCtrl == null)
                return;

            if (mInPlaceCtrl is PropInPlaceDateTime)
            {
                valueRect.Height--;

                Win32Calls.RECT rect = new Win32Calls.RECT();
                Win32Calls.GetWindowRect(mInPlaceCtrl.Handle, ref rect);
                Rectangle bounds = Rectangle.FromLTRB(rect.Left, rect.Top, rect.Right, rect.Bottom);
                bounds = mInPlaceCtrl.Parent.RectangleToClient(bounds);

                if (bounds != valueRect)
                {
                    mInPlaceCtrl.Invalidate();

                    // Bounds doesn't work because of DateTimePicker.PreferredHeight
                    Win32Calls.SetWindowPos(mInPlaceCtrl.Handle, IntPtr.Zero, valueRect.Left, valueRect.Top,
                        valueRect.Width, valueRect.Height, Win32Calls.SWP_NOZORDER | Win32Calls.SWP_NOACTIVATE |
                        Win32Calls.SWP_NOREDRAW);

                    // Causes WM_NCPAINT
                    Win32Calls.RedrawWindow(mInPlaceCtrl.Handle, IntPtr.Zero, IntPtr.Zero, 0x0561);
                }
            }
            else
            {
                // Find where the string is actually displayed (a look instance could place it anywhere)
                Graphics graphics = mParentWnd.CreateGraphics();
                Rectangle strRect = propEnum.Property.Value.GetStringValueRect(graphics, valueRect, Point.Empty /* not used */);
                strRect.X -= (propEnum.Property.Value.EditboxLeftMargin == -1 ? propEnum.Property.ParentGrid.GlobalTextMargin :
                    propEnum.Property.Value.EditboxLeftMargin);
                strRect.Width = valueRect.Right - strRect.Left;

                // Calculate the height of the editbox, based on the font height

                Rectangle editRect = strRect;
                editRect.Inflate(0, -1);

                Win32Calls.TEXTMETRIC tm = new Win32Calls.TEXTMETRIC();
                Win32Calls.GetTextMetrics(graphics, mInPlaceCtrl.Font, ref tm);

                graphics.Dispose();

                int extraHeight = editRect.Height - tm.tmHeight;
                editRect.Y += extraHeight / 2;
                editRect.Height -= extraHeight;

                if (mInPlaceCtrl.Bounds != editRect)
                    mInPlaceCtrl.Bounds = editRect;
            }
        }
        public override void OnDraw(Graphics graphics, Rectangle valueRect, Color textColor, PropertyEnumerator propEnum, string drawAnotherString)
        {
            if ((drawAnotherString != null) && (drawAnotherString.Length == 0))
                return;

            Rectangle strRect = GetDisplayStringRect(graphics, valueRect, Point.Empty /* not used */);
            strRect.Y += 2;
            strRect.Height = valueRect.Bottom - 2 - strRect.Y;

            Win32Calls.DrawText(graphics, DisplayString, ref strRect, Value.Font, textColor,
                Win32Calls.DT_WORDBREAK | Win32Calls.DT_EDITCONTROL | Win32Calls.DT_NOPREFIX);
        }
예제 #44
0
        /// <summary>
        /// Searches a property given its ID inside the whole property tree but only from a given enumerator and beyond.
        /// The enumerator can be sibling or deep and will restrict the search accordingly.
        /// </summary>
        /// <param name="afterEnumerator">The enumerator from which the property will be searched.</param>
        /// <param name="propertyId">The ID of the property being searched.</param>
        /// <returns>A deep enumerator pointing to the found property. If not found it will point to RightBound.</returns>
        public PropertyEnumerator FindAfter(PropertyEnumerator afterEnumerator, int propertyId)
        {
            PropertyEnumerator propEnum = new PropertyDeepEnumerator(afterEnumerator.Node);
            while (propEnum.MoveNext() != propEnum.RightBound)
            {
                if (propEnum.Property.Id == propertyId)
                    break;
            }

            // If the element is not found, the enumerator will point to RightBound
            return propEnum;
        }
예제 #45
0
        public virtual Rectangle GetLabelTextRect(Rectangle itemRect, PropertyEnumerator enumSelf)
        {
            Rectangle labelRect = itemRect;

            Rectangle imgRect = GetImageRect(itemRect, enumSelf);

            if (imgRect != Rectangle.Empty)
            {
                labelRect.X = imgRect.Right;
            }
            else
            {
                Rectangle checkboxRect = GetManuallyDisableRect(itemRect, enumSelf);
                if (checkboxRect != Rectangle.Empty)
                {
                    labelRect.X = checkboxRect.Right;
                }
                else
                {
                    Rectangle signRect = GetSignRect(itemRect, enumSelf);
                    if (signRect != Rectangle.Empty)
                    {
                        labelRect.X = signRect.Right;
                    }
                    else
                    {
                        labelRect.X = ParentGrid.LeftColumnWidth + 1 +
                                      (enumSelf.Depth - 1) * (_grid.GlobalTextMargin + TreeGlyphWidth);
                    }
                }
            }

            labelRect.X += _grid.GlobalTextMargin;

            Graphics graphics = ParentGrid.CreateGraphics();

            labelRect.Width = Win32Calls.GetTextExtent(graphics, DisplayName, Font).Width;
            graphics.Dispose();

            int maxRight = ParentGrid.LeftColumnWidth + 1 + ParentGrid.LabelColumnWidth;

            if ((ParentGrid.EllipsisMode & PropertyGrid.EllipsisModes.EllipsisOnLabels) != 0)
            {
                maxRight -= _grid.GlobalTextMargin;
            }

            if (labelRect.Right > maxRight)
            {
                labelRect.Width = maxRight - labelRect.Left;
            }

            return(labelRect);
        }
예제 #46
0
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if (propEnum.Property.Value.ReadOnly)
            {
                PropInPlaceTextbox edit;

                if ((mInPlaceCtrl == null) || !(mInPlaceCtrl is PropInPlaceTextbox))
                {
                    edit         = new PropInPlaceTextbox(false);
                    edit.Visible = false;
                    edit.Parent  = mParentWnd;
                    mInPlaceCtrl = edit;
                }
                else
                {
                    edit = (PropInPlaceTextbox)mInPlaceCtrl;
                }

                NotifyInPlaceControlCreated(propEnum);

                edit.OwnerPropertyEnumerator = propEnum;
                edit.Font = propEnum.Property.Value.Font;
//                if (edit.Text != propEnum.Property.Value.DisplayString)
//                  edit.Text = propEnum.Property.Value.DisplayString;
            }
            else
            {
                PropInPlaceDateTime dateTime;

                if ((mInPlaceCtrl == null) || !(mInPlaceCtrl is PropInPlaceDateTime))
                {
                    dateTime         = new PropInPlaceDateTime();
                    dateTime.Visible = false;
                    dateTime.Parent  = mParentWnd;
#if _DOTNET2
                    dateTime.AutoSize = false;
#endif
                    mInPlaceCtrl = dateTime;
                }
                else
                {
                    dateTime = (PropInPlaceDateTime)mInPlaceCtrl;
                }

                dateTime.OwnerPropertyEnumerator = propEnum;
                dateTime.Font = propEnum.Property.Value.Font;
//                dateTime.Value = (DateTime)propEnum.Property.Value.GetValue();
            }

            MoveControl(valueRect, propEnum);

            return(base.ShowControl(valueRect, propEnum));
        }
예제 #47
0
    private void GetSubProperties(PropertyEnumerator rootProperty, String propertyPath)
    {
      ArrayList propertyList = new ArrayList();
      state.GetSubTags(out requestId, propertyPath, out propertyList);

      foreach (ModelProperty modelProperty in propertyList)
      {
        PropertyEnumerator propertyEnum = AppendManagedProperty(rootProperty, id++, modelProperty.Path, modelProperty.State.GetType(), modelProperty.State, "");
        AppendManagedProperty(propertyEnum, -1, "", typeof(dummyType), new dummyType(), "");
        ExpandProperty(propertyEnum, false);
      }

    }
예제 #48
0
        internal override void OnPropertyClicked(PropertyEnumerator enumSelf, Point point, Rectangle itemRect)
        {
            if ((ParentGrid.Enabled == false) && (ParentGrid.DisableMode != PropertyGrid.DisableModes.None))
                return;

            Rectangle labelRect = GetLabelTextRect(itemRect, enumSelf);

            if (labelRect.Contains(point))
            {
                PropertyHyperLinkClickedEventArgs ev = new PropertyHyperLinkClickedEventArgs(enumSelf, HyperLink);
                ParentGrid.OnHyperLinkPropertyClicked(ev);
            }
        }
예제 #49
0
        public void SetText(string text, PropertyEnumerator enumerator)
        {
            if ((_title != text) || (_enumerator != enumerator))
            {
                _title = "";
                Win32Calls.SendMessage(Handle, Win32Calls.TTM_UPDATETIPTEXT, 0, GetTOOLINFO());

                _title = text;
                Win32Calls.SendMessage(Handle, Win32Calls.TTM_UPDATETIPTEXT, 0, GetTOOLINFO());
            }

            _enumerator = enumerator;
        }
예제 #50
0
        public void SetText(string text, PropertyEnumerator enumerator)
        {
            if ((_title != text) || (_enumerator != enumerator))
            {
                _title = "";
                Win32Calls.SendMessage(Handle, Win32Calls.TTM_UPDATETIPTEXT, 0, GetTOOLINFO());

                _title = text;
                Win32Calls.SendMessage(Handle, Win32Calls.TTM_UPDATETIPTEXT, 0, GetTOOLINFO());
            }

            _enumerator = enumerator;
        }
예제 #51
0
        public virtual Rectangle GetImageRect(Rectangle itemRect, PropertyEnumerator enumSelf)
        {
            if (ImageIndex == -1)
            {
                return(Rectangle.Empty);
            }

            Rectangle imgRect = itemRect;

            Rectangle checkboxRect = GetManuallyDisableRect(itemRect, enumSelf);

            if (checkboxRect != Rectangle.Empty)
            {
                imgRect.X = checkboxRect.Right + _grid.GlobalTextMargin;
            }
            else
            {
                Rectangle signRect = GetSignRect(itemRect, enumSelf);
                if (signRect != Rectangle.Empty)
                {
                    imgRect.X = signRect.Right + _grid.GlobalTextMargin;
                }
                else
                {
                    if (enumSelf.Depth == 0)
                    {
                        imgRect.X = ParentGrid.LeftColumnWidth + 1 + _grid.GlobalTextMargin;
                    }
                    else
                    {
                        imgRect.X = ParentGrid.LeftColumnWidth + 1 + _grid.GlobalTextMargin +
                                    (enumSelf.Depth - 1) * (_grid.GlobalTextMargin + TreeGlyphWidth);
                    }
                }
            }

            try
            {
                Image img = ParentGrid.ImageList.Images[ImageIndex];
                imgRect.Width  = img.Width;
                imgRect.Height = img.Height;
            }
            catch (Exception)
            {
                return(Rectangle.Empty);
            }

            imgRect.Y = itemRect.Top + ParentGrid.BasicPropertyHeight / 2 - 8;

            return(imgRect);
        }
예제 #52
0
        internal void SetManuallyDisabled(PropertyEnumerator propEnum, object containerInstance, string memberName)
        {
            if (containerInstance != null)
            {
                _canBeDisabledManually = true;
                _enabledVariable       = new PropertyValueIndirect(_grid, null, containerInstance, TypeDescriptor.GetProperties(containerInstance)[memberName], null);
                _enabledVariable.Grid  = ParentGrid;
                ParentGrid.EnableProperty(propEnum, (GetManuallyDisabledVariable() && !ParentGrid.Grid.IsAncestorDisabled(propEnum)));
//                _enabled = (GetManuallyDisabledVariable() && !ParentGrid.Grid.IsAncestorDisabled(propEnum));

//                if (_grid != null)
//                  _grid.Grid.Invalidate();
            }
        }
예제 #53
0
        //private TriStateBool _readonlyByPropertyDescriptor = TriStateBool.tsUndefined;

        public override bool IsReadOnly(PropertyEnumerator selfEnum)
        {
            if (!Grid.Grid.Enabled && (Grid.DisableMode == PropertyGrid.DisableModes.Simple))
            {
                return(true);
            }

            if ((selfEnum.Parent.Property != null) && (selfEnum.Parent.Property.Value != null))
            {
                if (!selfEnum.Parent.Property.Value.NoLinkWithChildren &&
                    (selfEnum.Parent.Property.Value.IsReadOnly(selfEnum.Parent)))
                {
                    return(true);
                }
            }

            // Check if a UITypeEditor has been found. Even if the property is marked Readonly (has only a get
            // accessor for example), the presence of an editor makes it editable (this is the case for collections
            // for example in the .net framework)
            ReadOnlyAttribute manualReadOnlyAttr = (ReadOnlyAttribute)base.GetAttribute(typeof(ReadOnlyAttribute));

            if ((mFeel is PropertyUITypeEditorFeel) && ((manualReadOnlyAttr == null) || !manualReadOnlyAttr.IsReadOnly))
            {
                return(false);
            }

            bool readonlyPd          = ((PropertyDescriptor)((Utilities.KeyValuePair)_targets[0]).Key).IsReadOnly;
            ReadOnlyAttribute attr   = (ReadOnlyAttribute)selfEnum.Property.Value.GetAttribute(typeof(ReadOnlyAttribute));
            bool readonlyByAttribute = (attr != null && attr.IsReadOnly);
            bool ro = (readonlyPd || readonlyByAttribute);

            /*
             * // Some checks on the readonly state (it could have been changed by a PropertyDescriptor)
             * if (_readonlyByPropertyDescriptor != TriStateBool.tsUndefined)
             * {
             *  if ((readonlyPd && (_readonlyByPropertyDescriptor == TriStateBool.tsFalse)) ||
             *      (!readonlyPd && (_readonlyByPropertyDescriptor == TriStateBool.tsTrue)))
             *  {
             *      if (ro && (selfEnum.Property.ParentGrid.ReadOnlyVisual == PropertyGrid.ReadOnlyVisuals.Disabled) &&
             *          selfEnum.Property.Enabled)
             *          selfEnum.Property.ParentGrid.EnableProperty(selfEnum, false);
             *      else if (!ro && !selfEnum.Property.Enabled)
             *          selfEnum.Property.ParentGrid.EnableProperty(selfEnum, true);
             *  }
             * }
             *
             * _readonlyByPropertyDescriptor = (readonlyPd ? TriStateBool.tsTrue : TriStateBool.tsFalse);
             */
            return(ro);
        }
예제 #54
0
        public override Control ShowControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if (propEnum.Property.Value.ReadOnly)
            {
                PropInPlaceTextbox edit;

                if ((mInPlaceCtrl == null) || !(mInPlaceCtrl is PropInPlaceTextbox))
                {
                    edit = new PropInPlaceTextbox(false);
                    edit.Visible = false;
                    edit.Parent = mParentWnd;
                    mInPlaceCtrl = edit;
                }
                else
                    edit = (PropInPlaceTextbox)mInPlaceCtrl;

                NotifyInPlaceControlCreated(propEnum);

                edit.OwnerPropertyEnumerator = propEnum;
                edit.Font = propEnum.Property.Value.Font;
//                if (edit.Text != propEnum.Property.Value.DisplayString)
  //                  edit.Text = propEnum.Property.Value.DisplayString;
            }
            else
            {
                PropInPlaceDateTime dateTime;

                if ((mInPlaceCtrl == null) || !(mInPlaceCtrl is PropInPlaceDateTime))
                {
                    dateTime = new PropInPlaceDateTime();
                    dateTime.Visible = false;
                    dateTime.Parent = mParentWnd;
#if _DOTNET2
                    dateTime.AutoSize = false;
#endif
                    mInPlaceCtrl = dateTime;
                }
                else
                    dateTime = (PropInPlaceDateTime)mInPlaceCtrl;

                dateTime.OwnerPropertyEnumerator = propEnum;
                dateTime.Font = propEnum.Property.Value.Font;
//                dateTime.Value = (DateTime)propEnum.Property.Value.GetValue();
            }

            MoveControl(valueRect, propEnum);

            return base.ShowControl(valueRect, propEnum);
        }
예제 #55
0
        public override bool OverrideCursor(Point mouseLocation, Rectangle itemRect, PropertyEnumerator propEnum)
        {
            if ((ParentGrid.Enabled == false) && (ParentGrid.DisableMode != PropertyGrid.DisableModes.None))
                return false;

            Rectangle labelRect = GetLabelTextRect(itemRect, propEnum);

            if (labelRect.Contains(mouseLocation) && Enabled)
            {
                ParentGrid.Grid.Cursor = Cursors.Hand;
                return true;
	        }

	        return false;
        }
예제 #56
0
        public override void OnDraw(Graphics graphics, Rectangle valueRect, Color textColor, PropertyEnumerator propEnum, string drawAnotherString)
        {
            if ((drawAnotherString != null) && (drawAnotherString.Length == 0))
                return;

            valueRect.Height++;

            Rectangle strRect = GetDisplayStringRect(graphics, valueRect, Point.Empty);
            strRect.Width = valueRect.Right - strRect.Left;

            Win32Calls.DrawText(graphics, (drawAnotherString == null ? GetDisplayStringInternal() : drawAnotherString),
                ref strRect, Value.Font, textColor,
                Win32Calls.DT_VCENTER | Win32Calls.DT_SINGLELINE | Win32Calls.DT_NOPREFIX |
                ((Value.Grid.EllipsisMode & PropertyGrid.EllipsisModes.EllipsisOnValues) != 0 ? Win32Calls.DT_END_ELLIPSIS : 0));
        }
예제 #57
0
        public override void OnDraw(Graphics graphics, Rectangle valueRect, Color textColor, PropertyEnumerator propEnum, string drawAnotherString)
        {
            if ((drawAnotherString != null) && (drawAnotherString.Length == 0))
                return;

            Pen pen = (Pen)propEnum.Property.Value.GetValue();
            if (pen.Width > valueRect.Height - 2)
            {
                pen = (Pen)pen.Clone();
                pen.Width = valueRect.Height - 2;
            }

            int margin = Value.Grid.GlobalTextMargin;
            graphics.DrawLine(pen, valueRect.Left + margin, valueRect.Top + valueRect.Height / 2,
                valueRect.Right - margin, valueRect.Top + valueRect.Height / 2);
        }
예제 #58
0
        public override void OnDraw(Graphics graphics, Rectangle valueRect, Color textColor, PropertyEnumerator propEnum, string drawAnotherString)
        {
            if ((drawAnotherString != null) && (drawAnotherString.Length == 0))
                return;

            valueRect.Height++;

            Rectangle strRect = GetDisplayStringRect(graphics, valueRect, Point.Empty /* not used */);

            strRect.Y += (Value.Grid.PropertyVerticalMargin % 2 == 0 ? 1 : 0);
            strRect.X -= Value.Grid.GlobalTextMargin - 3;
            strRect.Width = valueRect.Right - strRect.Left;

            StringFormat stringFormat = (StringFormat)StringFormat.GenericDefault.Clone();
            stringFormat.FormatFlags = StringFormatFlags.NoWrap;
            stringFormat.LineAlignment = StringAlignment.Center;
            graphics.DrawString(DisplayString, Value.Font, new SolidBrush(textColor), strRect, stringFormat);
        }
        public override void MoveControl(Rectangle valueRect, PropertyEnumerator propEnum)
        {
            if (mInPlaceCtrl == null)
                return;

            Graphics graphics = mParentWnd.CreateGraphics();
            Rectangle strRect = propEnum.Property.Value.GetStringValueRect(graphics, valueRect, Point.Empty /* not used */);
            graphics.Dispose();
            int margin = propEnum.Property.ParentGrid.GlobalTextMargin;
            strRect.X -= (propEnum.Property.Value.EditboxLeftMargin == -1 ? margin :
                propEnum.Property.Value.EditboxLeftMargin);
            strRect.Width = valueRect.Right - strRect.Left - margin;
            strRect.Y += 2;
            strRect.Height = valueRect.Bottom - strRect.Y - 1;

            if (mInPlaceCtrl.Bounds != strRect)
                mInPlaceCtrl.Bounds = strRect;
        }
예제 #60
0
        public override void OnDraw(Graphics graphics, Rectangle valueRect, Color textColor, PropertyEnumerator propEnum, string drawAnotherString)
        {
            if ((drawAnotherString != null) && (drawAnotherString.Length == 0))
                return;

            if (propEnum.Property.Value.HasMultipleValues)
                return;

            Rectangle colorRect = valueRect;
            colorRect.Y += 4;
            colorRect.Height -= 9;
            int margin = propEnum.Property.ParentGrid.GlobalTextMargin;
            colorRect.X += margin;
            colorRect.Width -= 2 * margin;

            Brush whiteBrush = new SolidBrush(Color.White);
            Brush grayBrush = new SolidBrush(Color.Gray);
            for (int y = colorRect.Top + 1; y < colorRect.Bottom; y += 4)
            {
                int height = (y + 4 > colorRect.Bottom ? colorRect.Bottom - y : 4);
                for (int x = colorRect.Left + 1; x < colorRect.Right; x += 5)
                {
                    int width = (x + 5 > colorRect.Right ? colorRect.Right - x : 5);
                    if (((x - (colorRect.Left + 1)) % 10 == ((y - (colorRect.Top + 1)) % 8 == 0 ? 0 : 5)))
                        graphics.FillRectangle(whiteBrush, x, y, width, height);
                    else
                        graphics.FillRectangle(grayBrush, x, y, width, height);
                }
            }

            whiteBrush.Dispose();
            grayBrush.Dispose();

            // Draw the color with alpha
            Brush brush = new SolidBrush((Color)Value.GetActualValue(drawAnotherString));
            graphics.FillRectangle(brush, colorRect);
            brush.Dispose();

            // Draw a black frame around
            Pen blackPen = new Pen(Color.Black);
            graphics.DrawRectangle(blackPen, colorRect);
            blackPen.Dispose();
        }